@equationalapplications/core-llm-wiki 4.15.3 → 4.16.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { __privateAdd, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, generateId } from './chunk-J4GBC6CP.mjs';
-export { HOOK_TIMEOUT_MARKER, PromptService, PrunePartialFailureError, WikiBusyError, parseEmbedding } from './chunk-J4GBC6CP.mjs';
+import { __privateAdd, EmbeddingService, SearchService, JobManager, PromptService, IngestionService, MaintenanceService, ImportExportService, RetrievalService, WriteService, __privateGet, __privateSet, normalizeSourceRef, normalizeSourceHash, generateId, validateManifest, emptyManifest, mergeOntologyUpdates, resolveNodeType, validateInlineEdges, resolveEdgeDefinition, normalizeTitleKey } from './chunk-2BGLPRT3.mjs';
+export { HOOK_TIMEOUT_MARKER, PromptService, PrunePartialFailureError, WikiBusyError, parseEmbedding } from './chunk-2BGLPRT3.mjs';
 import { buildConceptDocument, buildLogMd, buildIndexMd, buildRootIndexMd, parseConcept, extractMarkdownLinks, parseLogMd } from '@equationalapplications/core-okf';
 
 // src/db/schema.ts
@@ -74,6 +74,13 @@ async function setupDatabase(db, prefix) {
       memory_checkpoint INTEGER NOT NULL DEFAULT 0
     );
 
+    CREATE TABLE IF NOT EXISTS ${prefix}entity_manifests (
+      entity_id TEXT PRIMARY KEY,
+      mode TEXT NOT NULL DEFAULT 'off',
+      manifest_json TEXT NOT NULL DEFAULT '{"node_types":[],"edge_types":[]}',
+      updated_at INTEGER NOT NULL
+    );
+
     CREATE TABLE IF NOT EXISTS ${prefix}meta (
       key TEXT PRIMARY KEY,
       value TEXT NOT NULL
@@ -183,6 +190,20 @@ var MIGRATIONS = [
         CREATE INDEX IF NOT EXISTS ${prefix}edges_entity_idx ON ${prefix}edges (entity_id);
       `);
     }
+  },
+  {
+    version: 6,
+    description: "Add entity_manifests table for per-entity ontology state",
+    run: async (db, prefix) => {
+      await db.execAsync(`
+        CREATE TABLE IF NOT EXISTS ${prefix}entity_manifests (
+          entity_id TEXT PRIMARY KEY,
+          mode TEXT NOT NULL DEFAULT 'off',
+          manifest_json TEXT NOT NULL DEFAULT '{"node_types":[],"edge_types":[]}',
+          updated_at INTEGER NOT NULL
+        );
+      `);
+    }
   }
 ];
 for (let i = 1; i < MIGRATIONS.length; i++) {
@@ -306,8 +327,8 @@ var EntryRepository = class extends BaseRepository {
       `INSERT INTO ${this.prefix}entries (
         id, entity_id, title, body, tags, confidence, source_type,
         source_hash, source_ref, created_at, updated_at, last_accessed_at, access_count,
-        deleted_at, embedding_blob, embedding
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        deleted_at, embedding_blob, embedding, okf_type
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         entity_id = excluded.entity_id,
         title = excluded.title,
@@ -322,7 +343,8 @@ var EntryRepository = class extends BaseRepository {
         access_count = excluded.access_count,
         deleted_at = excluded.deleted_at,
         embedding_blob = CASE WHEN excluded.embedding_blob IS NULL THEN embedding_blob ELSE excluded.embedding_blob END,
-        embedding = NULL`,
+        embedding = NULL,
+        okf_type = excluded.okf_type`,
       [
         fact.id,
         fact.entity_id,
@@ -339,7 +361,8 @@ var EntryRepository = class extends BaseRepository {
         fact.access_count,
         fact.deleted_at ?? null,
         embeddingBlob ?? null,
-        null
+        null,
+        fact.okf_type ?? null
       ]
     );
     await this.outbox.push({
@@ -1500,6 +1523,151 @@ var MetadataRepository = class extends BaseRepository {
     );
     return rows.map((r) => r.entity_id);
   }
+  async getManifest(entityId, tx) {
+    const executor = this.getExecutor(tx);
+    const row = await executor.getFirstAsync(`SELECT mode, manifest_json FROM ${this.prefix}entity_manifests WHERE entity_id = ?`, [entityId]);
+    if (!row) return null;
+    if (row.mode !== "off" && row.mode !== "strict" && row.mode !== "emergent") {
+      throw new Error(`Invalid ontology mode for entity ${entityId}: ${JSON.stringify(row.mode)}`);
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(row.manifest_json);
+    } catch (error) {
+      throw new Error(`Invalid manifest_json for entity ${entityId}: ${error.message}`);
+    }
+    validateManifest(manifest);
+    return {
+      mode: row.mode,
+      manifest
+    };
+  }
+  async setManifest(entityId, data, tx) {
+    validateManifest(data.manifest);
+    const executor = this.getExecutor(tx);
+    await executor.runAsync(
+      `INSERT INTO ${this.prefix}entity_manifests (entity_id, mode, manifest_json, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(entity_id) DO UPDATE SET mode = excluded.mode, manifest_json = excluded.manifest_json, updated_at = excluded.updated_at`,
+      [entityId, data.mode, JSON.stringify(data.manifest), Date.now()]
+    );
+  }
+  async mergeManifestUpdates(entityId, updates, tx) {
+    const current = await this.getManifest(entityId, tx) ?? {
+      mode: "emergent",
+      manifest: emptyManifest()
+    };
+    const merged = mergeOntologyUpdates(current.manifest, updates);
+    await this.setManifest(entityId, { mode: current.mode, manifest: merged }, tx);
+    return merged;
+  }
+};
+
+// src/prompts/ontology.ts
+var FACT_ONTOLOGY_FIELDS = `
+Each fact may optionally include:
+- "okf_type": string \u2014 must be one of the node_types in the manifest
+- "edges": [{ "edge_type": string, "target_title": string }] \u2014 target_title must match another fact's title in this response or existing memory`;
+var EMERGENT_EXTRA = `
+You may also return "ontology_updates" to propose new types:
+"ontology_updates": {
+  "node_types": [{ "type": "slug", "description": "..." }],
+  "edge_types": [{ "type": "slug", "source_type": "...", "target_type": "...", "description": "..." }]
+}
+Only propose types not already in the manifest. Do not redefine existing types.`;
+function buildOntologyPromptAppendix(mode, manifestJson) {
+  const strictRules = mode === "strict" ? "STRICT MODE: Use ONLY types defined in the manifest. If a fact does not fit any node_type, omit okf_type and edges entirely." : "EMERGENT MODE: Prefer manifest types. You may propose new types via ontology_updates when necessary.";
+  const fallback = "If okf_type or an edge is invalid, omit them rather than inventing unlisted types.";
+  const ontologyModeInstructions = [
+    "## Ontology constraints",
+    strictRules,
+    fallback,
+    FACT_ONTOLOGY_FIELDS,
+    mode === "emergent" ? EMERGENT_EXTRA : "",
+    "Manifest:",
+    manifestJson
+  ].filter(Boolean).join("\n");
+  return { ontologyManifest: manifestJson, ontologyModeInstructions };
+}
+
+// src/services/OntologyService.ts
+var OntologyService = class {
+  constructor(metadataRepo, edgeRepo, ontologyConfig) {
+    this.metadataRepo = metadataRepo;
+    this.edgeRepo = edgeRepo;
+    this.ontologyConfig = ontologyConfig;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  resolveMode(storedMode) {
+    return storedMode ?? this.ontologyConfig?.mode ?? "off";
+  }
+  invalidateCache(entityId) {
+    this.cache.delete(entityId);
+  }
+  async getEffectiveState(entityId, tx) {
+    if (!tx) {
+      const cached = this.cache.get(entityId);
+      if (cached) return cached;
+    }
+    const row = await this.metadataRepo.getManifest(entityId, tx);
+    if (row) {
+      const state = { mode: this.resolveMode(row.mode), manifest: row.manifest };
+      if (!tx) this.cache.set(entityId, state);
+      return state;
+    }
+    const seed = this.ontologyConfig?.seedManifests?.[entityId];
+    if (seed) {
+      const state = {
+        mode: this.resolveMode(seed.mode),
+        manifest: seed.manifest
+      };
+      if (tx) {
+        await this.metadataRepo.setManifest(entityId, state, tx);
+      } else {
+        this.cache.set(entityId, state);
+      }
+      return state;
+    }
+    return { mode: "off", manifest: emptyManifest() };
+  }
+  async buildPromptContext(entityId) {
+    const { mode, manifest } = await this.getEffectiveState(entityId);
+    if (mode === "off") return null;
+    const manifestJson = JSON.stringify(manifest, null, 2);
+    return buildOntologyPromptAppendix(mode, manifestJson);
+  }
+  async mergeEmergentUpdates(entityId, updates, tx) {
+    const merged = await this.metadataRepo.mergeManifestUpdates(entityId, updates, tx);
+    this.invalidateCache(entityId);
+    return merged;
+  }
+  validateAndNormalizeFact(fact, manifest) {
+    const rawType = typeof fact.okf_type === "string" ? fact.okf_type : "";
+    const canonical = resolveNodeType(rawType, manifest);
+    if (!canonical) return { okf_type: null, edges: [] };
+    const edges = validateInlineEdges(canonical, null, fact.edges ?? [], manifest);
+    return { okf_type: canonical, edges };
+  }
+  async resolveAndPersistEdges(entityId, sourceId, sourceType, edges, manifest, titleIndex, tx, now) {
+    if (!sourceType || edges.length === 0) return;
+    for (const edge of edges) {
+      const def = resolveEdgeDefinition(edge.edge_type, manifest);
+      if (!def || def.source_type.toLowerCase() !== sourceType.toLowerCase()) continue;
+      const targetKey = normalizeTitleKey(edge.target_title);
+      const target = titleIndex.get(targetKey);
+      if (!target) continue;
+      if (def.target_type.toLowerCase() !== (target.okf_type ?? "").toLowerCase()) continue;
+      const wikiEdge = {
+        id: generateId(),
+        entity_id: entityId,
+        source_id: sourceId,
+        target_id: target.id,
+        edge_type: def.type,
+        created_at: now
+      };
+      await this.edgeRepo.addIgnoreDuplicate(wikiEdge, tx);
+    }
+  }
 };
 
 // src/WikiMemory.ts
@@ -1523,6 +1691,11 @@ var WikiMemory = class {
     this.eventRepo = new EventRepository(db, this.prefix);
     this.edgeRepo = new EdgeRepository(db, this.prefix);
     this.metadataRepo = new MetadataRepository(db, this.prefix);
+    this.ontologyService = new OntologyService(
+      this.metadataRepo,
+      this.edgeRepo,
+      options.config?.ontology
+    );
     this.embeddingService = new EmbeddingService(this.db, this.options, this.entryRepo, this.metadataRepo);
     this.searchService = new SearchService(this.entryRepo);
     this.jobManager = new JobManager(this.prefix);
@@ -1535,7 +1708,8 @@ var WikiMemory = class {
       this.searchService,
       this.jobManager,
       this.embeddingService,
-      this.promptService
+      this.promptService,
+      this.ontologyService
     );
     this.maintenanceService = new MaintenanceService(
       this.db,
@@ -1548,7 +1722,8 @@ var WikiMemory = class {
       this.searchService,
       this.jobManager,
       this.embeddingService,
-      this.promptService
+      this.promptService,
+      this.ontologyService
     );
     this.importExportService = new ImportExportService(
       this.db,
@@ -1743,6 +1918,34 @@ var WikiMemory = class {
   async markOutboxEventsProcessed(eventIds) {
     await this.outboxRepo.acknowledge(eventIds);
   }
+  /**
+   * Returns the effective ontology mode and manifest for an entity.
+   * Resolution order: persisted DB row → `WikiConfig.ontology.seedManifests[entityId]` → `null`.
+   */
+  async getOntologyManifest(entityId) {
+    const row = await this.metadataRepo.getManifest(entityId);
+    if (row) return { mode: this.ontologyService.resolveMode(row.mode), manifest: row.manifest };
+    const seed = this.options.config?.ontology?.seedManifests?.[entityId];
+    if (seed) {
+      return {
+        mode: this.ontologyService.resolveMode(seed.mode),
+        manifest: seed.manifest
+      };
+    }
+    return null;
+  }
+  /**
+   * Seeds or replaces an entity's ontology manifest and optional mode override.
+   * Validates manifest invariants (unique type slugs, edge endpoints reference node types).
+   * Invalidates the in-memory ontology cache for this entity.
+   */
+  async setOntologyManifest(entityId, manifest, options) {
+    const mode = options?.mode ?? this.ontologyService.resolveMode();
+    await this.db.withTransactionAsync(
+      (tx) => this.metadataRepo.setManifest(entityId, { mode, manifest }, tx)
+    );
+    this.ontologyService.invalidateCache(entityId);
+  }
 };
 _testAccessNonTestEnvWarned = new WeakMap();