import { ManagerContext } from '@danielsimonjr/memoryjs';

// JSONL storage (default, human-readable)
const ctx = new ManagerContext('./memory.jsonl');

// Or SQLite (set MEMORY_STORAGE_TYPE=sqlite in the environment)
const sqliteCtx = new ManagerContext('./memory.db');

await ctx.entityManager.createEntities([
  {
    name: 'TypeScript',
    entityType: 'language',
    observations: ['A typed superset of JavaScript'],
    tags: ['programming', 'frontend'],
    importance: 8,
  },
  {
    name: 'Node.js',
    entityType: 'runtime',
    observations: ['JavaScript runtime built on V8'],
    tags: ['backend', 'server'],
  },
]);

await ctx.relationManager.createRelations([
  { from: 'TypeScript', to: 'Node.js', relationType: 'runs_on' },
]);

// Auto-select the best method
const auto = await ctx.searchManager.autoSearch('JavaScript');

// Substring + tag search
const nodes = await ctx.searchManager.searchNodes('JavaScript');

// Boolean (AND / OR / NOT) with an AST parser
const both = await ctx.searchManager.booleanSearch('TypeScript AND runtime');

// Fuzzy (typo-tolerant; N-gram pre-filtered)
const fuzzy = await ctx.searchManager.fuzzySearch('Typscript', { threshold: 0.7 });

// Ranked TF-IDF / BM25
const ranked = await ctx.rankedSearch.searchNodesRanked('runtime environment',
  undefined, undefined, undefined, 10);

// Active retrieval — iterative query rewriting until coverage threshold
const adaptive = await ctx.activeRetrieval.adaptiveRetrieve({ query: 'memory leak' });
console.log(adaptive.bestResults, adaptive.bestCoverage, adaptive.rounds);

// Optimistic concurrency control — fail loudly on stale writes
try {
  await ctx.entityManager.updateEntity('Alice',
    { importance: 9 },
    { expectedVersion: 3 });
} catch (e) {
  if (e instanceof Error && e.name === 'VersionConflictError') {
    // Refetch + retry
  }
}

// Synthesize a view across agents + resolve conflicts
const agent = ctx.agentMemory();
const synth = await agent.collaborativeSynthesis.synthesize('Alice');
const winners = agent.collaborativeSynthesis.resolveConflicts(synth, {
  strategy: 'highest_confidence',
});

// Enforce attribution on every mutation
import { CollaborationAuditEnforcer, AuditLog } from '@danielsimonjr/memoryjs';
const enforcer = new CollaborationAuditEnforcer(
  ctx.entityManager,
  new AuditLog('./audit.jsonl'),
);
await enforcer.createEntities(
  [{ name: 'X', entityType: 't', observations: ['fact'] }],
  'agent-alice', // throws AttributionRequiredError if agentId is missing
);

// Mark an entity as no longer valid at a specific time
await ctx.entityManager.invalidateEntity('OldFact', '2025-12-31T00:00:00Z');

// Time-travel query
const past = await ctx.entityManager.entityAsOf('Alice', '2024-06-15T00:00:00Z');

// Per-observation validity windows
await ctx.observationManager.invalidateObservation(
  'Alice', 'works at Acme', '2024-12-31T00:00:00Z',
);
const obsAtTime = await ctx.observationManager.observationsAsOf(
  'Alice', '2024-06-15T00:00:00Z',
);

// Forward inference — "what does X cause?"
const effects = await ctx.causalReasoner.findEffects('rain', ['flooding', 'erosion']);

// Counterfactual — "what if we remove this edge?"
const surviving = await ctx.causalReasoner.counterfactual({
  seed: 'rain', removeFrom: 'rain', removeTo: 'flooding', predict: 'flooding',
});

// World-state snapshot + diff
const before = await ctx.worldModelManager.getCurrentState();
// ... mutations ...
const after = await ctx.worldModelManager.getCurrentState();
const change = ctx.worldModelManager.detectStateChange(before, after);

// Grant a role
await ctx.roleAssignmentStore.assign({
  agentId: 'alice', role: 'writer', resourceType: 'entity',
});
ctx.rbacMiddleware.checkPermission('alice', 'write', 'entity'); // true

// Redact PII from exports / logs
import { PiiRedactor } from '@danielsimonjr/memoryjs';
const redactor = new PiiRedactor();
const cleanGraph = redactor.redactGraph(graph);
const { text, stats } = redactor.redactWithStats(observation);

interface Entity {
  name: string;              // Unique identifier
  entityType: string;        // Classification (person, project, concept, …)
  observations: string[];    // Atomic facts about the entity
  parentId?: string;         // Parent entity for hierarchical nesting
  tags?: string[];           // Lowercase tags for categorisation
  importance?: number;       // 0–10 scale for prioritisation
  createdAt?: string;        // ISO 8601
  lastModified?: string;     // ISO 8601

  // Freshness
  ttl?: number;              // Seconds until stale
  confidence?: number;       // [0, 1] belief strength

  // Project scoping + supersession
  projectId?: string;        // Multi-project isolation
  version?: number;          // Drives optimistic concurrency on updates
  parentEntityName?: string;
  rootEntityName?: string;
  isLatest?: boolean;
  supersededBy?: string;

  // Memory-engine deduplication
  contentHash?: string;      // SHA-256 for O(1) exact-equality dedup

  // Bitemporal validity (orthogonal to supersession)
  validFrom?: string;
  validUntil?: string;
  observationMeta?: Array<{
    content: string;
    validFrom?: string;
    validUntil?: string;
    recordedAt?: string;
  }>;
}

interface Relation {
  from: string;           // Source entity name
  to: string;             // Target entity name
  relationType: string;   // Relationship type (active voice — "depends_on", "wrote")
}

const ctx = new ManagerContext('./memory.jsonl');

// Core
ctx.entityManager        // Entity CRUD + hierarchy + temporal validity + OCC
ctx.relationManager      // Relation management + temporal invalidation
ctx.observationManager   // Observation CRUD + bitemporal axis
ctx.hierarchyManager     // Tree operations (parent / children / ancestors)
ctx.searchManager        // All search operations including `searchByTime`
ctx.rankedSearch         // TF-IDF / BM25 ranked search
ctx.graphTraversal       // BFS / DFS / shortest path / centrality / communities
ctx.tagManager           // Tag aliases + bulk operations
ctx.refIndex             // Stable name → entity O(1) lookup

// Storage + I/O
ctx.ioManager            // Import / export (RDF/Turtle/JSON-LD) / backup / ingest
ctx.archiveManager       // Entity archival
ctx.compressionManager   // Duplicate detection, entity merging
ctx.analyticsManager     // Graph statistics + validation
ctx.semanticForget       // Two-tier deletion with audit
ctx.governanceManager    // Transactions + policy enforcement
ctx.freshnessManager     // TTL / confidence freshness reports

// Search extensions
ctx.semanticSearch       // Vector similarity (lazy; needs embedding provider)
ctx.temporalSearch       // Natural-language time-range search
ctx.activeRetrieval      // Iterative query rewriting (no LLM required)
ctx.queryNaturalLanguage // Convenience wrapper for NL → StructuredQuery

// Memory engine + agent system
ctx.memoryEngine         // Turn-aware conversation memory (4-tier dedup)
ctx.memoryBackend        // Pluggable IMemoryBackend (in-memory / sqlite)
ctx.agentMemory()        // Agent Memory System facade

// Memory intelligence
ctx.memoryValidator      // Consistency / contradictions / temporal-order checks
ctx.trajectoryCompressor // Distill / abstract / merge redundant trajectories

// Specialised memory managers
ctx.procedureManager     // Executable procedure memory + feedback refinement
ctx.causalReasoner       // findCauses / findEffects / counterfactual
ctx.worldModelManager    // State-snapshot orchestrator + diff
ctx.heuristicManager     // Condition → action guidelines
ctx.decisionManager      // ADR-style decision records
ctx.projectContextManager
ctx.toolAffordanceManager
ctx.spellChecker         // Vocabulary-driven spell suggestions
ctx.exclusionManager     // `do_not_remember` content-pattern rules
ctx.observationDedupManager

// Access control + audit
ctx.roleAssignmentStore
ctx.rbacMiddleware

const ctx = new ManagerContext('./memory.jsonl');

// Set MEMORY_STORAGE_TYPE=sqlite environment variable
const ctx = new ManagerContext('./memory.db');

const auto = await ctx.searchManager.autoSearch('TypeScript runtime');
console.log(auto.selectedMethod, auto.selectionReason);
console.log(auto.results);

// AND — both terms must match
await ctx.searchManager.booleanSearch('TypeScript AND runtime');

// OR — either term matches
await ctx.searchManager.booleanSearch('frontend OR backend');

// NOT — exclude term
await ctx.searchManager.booleanSearch('JavaScript NOT browser');

// Grouping
await ctx.searchManager.booleanSearch('(TypeScript OR JavaScript) AND server');

// Typo-tolerant; threshold 0–1 (higher = stricter)
await ctx.searchManager.fuzzySearch('Typscript', { threshold: 0.7 });

import { HybridSearchManager } from '@danielsimonjr/memoryjs';

const hybrid = new HybridSearchManager(ctx.storage, ctx.rankedSearch);
const results = await hybrid.search('programming concepts', {
  weights: {
    semantic: 0.5,   // Vector similarity (requires embeddings)
    lexical: 0.3,    // TF-IDF text matching
    symbolic: 0.2,   // Metadata (tags, importance, type)
  },
  filters: {
    entityTypes: ['concept'],
    minImportance: 5,
    tags: ['programming'],
  },
});

// Shortest path between entities (BFS)
const result = await ctx.graphTraversal.findShortestPath('A', 'Z');
console.log(result.path);     // ['A', 'B', 'C', 'Z']
console.log(result.distance); // 3

// All paths with a depth bound
const all = await ctx.graphTraversal.findAllPaths('A', 'Z', { maxDepth: 5 });
// → [['A', 'B', 'Z'], ['A', 'C', 'D', 'Z'], …]

const degree = await ctx.graphTraversal.calculateDegreeCentrality();
const between = await ctx.graphTraversal.calculateBetweennessCentrality();
const pagerank = await ctx.graphTraversal.calculatePageRank();
const hits = await ctx.graphTraversal.calculateHITS();
// Each returns a Map<entityName, score>

const components = await ctx.graphTraversal.findConnectedComponents();
const communities = await ctx.graphTraversal.findCommunities();   // Louvain
const cliques = await ctx.graphTraversal.findCliques(/* minSize */ 3);

// Returns a TraversalResult { visited, edges, depthMap }
const bfs = ctx.graphTraversal.bfs('startNode', { maxDepth: 3 });
const dfs = ctx.graphTraversal.dfs('startNode');

import { ManagerContext } from '@danielsimonjr/memoryjs';

const ctx = new ManagerContext('./memory.jsonl');
const agent = ctx.agentMemory();

// Start a session
const session = await agent.startSession({ agentId: 'my-agent' });

// Add working memory
await agent.addWorkingMemory({
  sessionId: session.name,
  content: 'User prefers dark mode',
  importance: 7,
});

// Episodic event
await agent.createEpisode('Completed onboarding flow', {
  sessionId: session.name,
  importance: 8,
});

// Retrieve context for an LLM prompt (token-budgeted)
const context = await agent.retrieveForContext({
  maxTokens: 2000,
  includeEpisodic: true,
});

// End session
await agent.endSession(session.name);

type MemoryType =
  | 'working'      // Short-term, session-scoped; may be promoted
  | 'episodic'     // Timeline-based event memories
  | 'semantic'     // Long-term factual knowledge
  | 'procedural'   // Executable procedures with feedback refinement
  | 'prospective'  // Intentions-to-act at a future time / event / condition
  | 'failure'      // Pre-task failure lookup keyed on applicability_hint
  | 'plan'         // Hierarchical goal trees with sub-tasks + acceptance criteria
  | 'reflection'   // Additive derived insights with content-hash dedup
  | 'heuristic';   // Condition → action guidelines

const agent = ctx.agentMemory({
  decay: {
    halfLifeHours: 168,  // One-week half-life
    minImportance: 0.1,  // Never fully forget
  },
  enableAutoDecay: true,
});

// Reinforce a memory
await agent.confirmMemory('memory_name', 0.1);  // Boost confidence
await agent.promoteMemory('memory_name', 'episodic');  // Promote to long-term

// Register an agent
agent.registerAgent('agent_1', {
  name: 'Research Agent',
  type: 'llm',
  trustLevel: 0.8,
  capabilities: ['read', 'write'],
});

// Create with visibility (private / team / org / shared / public)
await agent.addWorkingMemory({
  sessionId: session.name,
  content: 'Shared insight',
  visibility: 'shared',
  ownerAgentId: 'agent_1',
});

// Cross-agent search
const results = await agent.searchCrossAgent('agent_2', 'query');