@zabaca/lattice 1.0.20 → 1.0.22

package/dist/main.js

@@ -989,29 +989,6 @@ class GraphService {
       return [];
     }
   }
-  async findNodesWithMissingEmbeddings(labels) {
-    try {
-      const conn = await this.ensureConnected();
-      const labelFilter = labels.map((l) => `'${this.escape(l)}'`).join(", ");
-      const reader = await conn.runAndReadAll(`
-				SELECT label, name, properties->>'description' as description
-				FROM nodes
-				WHERE label IN (${labelFilter})
-				  AND embedding IS NULL
-			`);
-      return reader.getRows().map((row) => {
-        const [label, name, description] = row;
-        return {
-          label,
-          name,
-          description: description || undefined
-        };
-      });
-    } catch (error) {
-      this.logger.error(`Failed to find nodes with missing embeddings: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
 }
 GraphService = __legacyDecorateClassTS([
   Injectable4(),
@@ -1312,13 +1289,18 @@ class VoyageEmbeddingProvider {
 class EmbeddingService {
   configService;
   logger = new Logger3(EmbeddingService.name);
-  provider;
+  provider = null;
   config;
   constructor(configService) {
     this.configService = configService;
     this.config = this.loadConfig();
-    this.provider = this.createProvider();
-    this.logger.log(`Initialized embedding service with provider: ${this.provider.name}`);
+  }
+  getProvider() {
+    if (!this.provider) {
+      this.provider = this.createProvider();
+      this.logger.log(`Initialized embedding provider: ${this.provider.name}`);
+    }
+    return this.provider;
   }
   loadConfig() {
     const providerEnv = this.configService.get("EMBEDDING_PROVIDER");
@@ -1365,35 +1347,36 @@ class EmbeddingService {
     }
   }
   getProviderName() {
-    return this.provider.name;
+    return this.getProvider().name;
   }
   getDimensions() {
-    return this.provider.dimensions;
+    return this.getProvider().dimensions;
   }
   async generateEmbedding(text) {
     if (!text || text.trim().length === 0) {
       throw new Error("Cannot generate embedding for empty text");
     }
-    return this.provider.generateEmbedding(text);
+    return this.getProvider().generateEmbedding(text);
   }
   async generateQueryEmbedding(text) {
     if (!text || text.trim().length === 0) {
       throw new Error("Cannot generate embedding for empty text");
     }
-    if (this.provider.generateQueryEmbedding) {
-      return this.provider.generateQueryEmbedding(text);
+    const provider = this.getProvider();
+    if (provider.generateQueryEmbedding) {
+      return provider.generateQueryEmbedding(text);
     }
-    return this.provider.generateEmbedding(text);
+    return provider.generateEmbedding(text);
   }
   async generateEmbeddings(texts) {
     const validTexts = texts.filter((t) => t && t.trim().length > 0);
     if (validTexts.length === 0) {
       return [];
     }
-    return this.provider.generateEmbeddings(validTexts);
+    return this.getProvider().generateEmbeddings(validTexts);
   }
   isRealProvider() {
-    return this.provider.name !== "mock";
+    return this.getProvider().name !== "mock";
   }
 }
 EmbeddingService = __legacyDecorateClassTS([
@@ -2059,6 +2042,11 @@ class DatabaseChangeDetectorService {
     this.hashCache.clear();
     this.loaded = false;
   }
+  clearEntries(paths) {
+    for (const path2 of paths) {
+      this.hashCache.delete(path2);
+    }
+  }
   getContentHash(content) {
     return createHash3("sha256").update(content).digest("hex");
   }
@@ -2236,30 +2224,30 @@ class SyncService {
       embeddingsGenerated: 0,
       entityEmbeddingsGenerated: 0
     };
-    const useDbDetection = options.legacy ? false : options.useDbChangeDetection ?? true;
-    const useAiExtraction = options.legacy ? false : options.aiExtraction ?? true;
+    const useAiExtraction = options.aiExtraction ?? true;
     try {
       await this.manifest.load();
-      if (useDbDetection) {
-        await this.dbChangeDetector.loadHashes();
-        if (options.verbose) {
-          this.logger.log(`v2 mode: Loaded ${this.dbChangeDetector.getCacheSize()} document hashes from database`);
-        }
+      await this.dbChangeDetector.loadHashes();
+      if (options.verbose) {
+        this.logger.log(`Loaded ${this.dbChangeDetector.getCacheSize()} document hashes from database`);
       }
       if (options.force) {
         if (options.paths && options.paths.length > 0) {
+          const normalizedPaths = this.pathResolver.resolveDocPaths(options.paths, { requireExists: true, requireInDocs: true });
           if (options.verbose) {
-            this.logger.log(`Force mode: marking ${options.paths.length} document(s) for re-sync`);
+            this.logger.log(`Force mode: marking ${normalizedPaths.length} document(s) for re-sync`);
           }
           await this.clearManifestEntries(options.paths);
+          this.dbChangeDetector.clearEntries(normalizedPaths);
         } else {
           if (options.verbose) {
-            this.logger.log("Force mode: clearing manifest to force full re-sync");
+            this.logger.log("Force mode: clearing tracking data to force full re-sync");
           }
           await this.clearManifest();
+          this.dbChangeDetector.reset();
         }
       }
-      const changes = await this.detectChanges(options.paths, useDbDetection);
+      const changes = await this.detectChanges(options.paths);
       result.changes = changes;
       const docsToSync = [];
       const docsByPath = new Map;
@@ -2328,10 +2316,6 @@ class SyncService {
       }
       if (!options.dryRun) {
         result.entityEmbeddingsGenerated = await this.syncEntities(uniqueEntities, options);
-        if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
-          const repairedCount = await this.repairMissingEntityEmbeddings(options);
-          result.entityEmbeddingsGenerated += repairedCount;
-        }
         await this.graph.checkpoint();
         if (options.verbose) {
           this.logger.log(`Synced ${uniqueEntities.size} entities, generated ${result.entityEmbeddingsGenerated} embeddings`);
@@ -2379,7 +2363,7 @@ class SyncService {
     result.duration = Date.now() - startTime;
     return result;
   }
-  async detectChanges(paths, useDbDetection = false) {
+  async detectChanges(paths) {
     const changes = [];
     let allDocPaths = await this.parser.discoverDocuments();
     if (paths && paths.length > 0) {
@@ -2390,11 +2374,11 @@ class SyncService {
       const pathSet = new Set(normalizedPaths);
       allDocPaths = allDocPaths.filter((p) => pathSet.has(p));
     }
-    const trackedPaths = new Set(useDbDetection ? this.dbChangeDetector.getTrackedPaths() : this.manifest.getTrackedPaths());
+    const trackedPaths = new Set(this.dbChangeDetector.getTrackedPaths());
     for (const docPath of allDocPaths) {
       try {
         const doc = await this.parser.parseDocument(docPath);
-        const changeType = useDbDetection ? this.dbChangeDetector.detectChange(docPath, doc.contentHash) : this.manifest.detectChange(docPath, doc.contentHash, doc.frontmatterHash);
+        const changeType = this.dbChangeDetector.detectChange(docPath, doc.contentHash);
         changes.push({
           path: docPath,
           changeType,
@@ -2551,11 +2535,8 @@ class SyncService {
         change.embeddingGenerated = embeddingGenerated;
         const currentDoc = await this.parser.parseDocument(change.path);
         this.manifest.updateEntry(currentDoc.path, currentDoc.contentHash, currentDoc.frontmatterHash, currentDoc.entities.length, currentDoc.relationships.length);
-        const shouldUpdateDbHashes = options.legacy ? false : options.useDbChangeDetection ?? true;
-        if (shouldUpdateDbHashes) {
-          const embeddingSourceHash = embeddingGenerated ? currentDoc.contentHash : undefined;
-          await this.graph.updateDocumentHashes(currentDoc.path, currentDoc.contentHash, embeddingSourceHash);
-        }
+        const embeddingSourceHash = embeddingGenerated ? currentDoc.contentHash : undefined;
+        await this.graph.updateDocumentHashes(currentDoc.path, currentDoc.contentHash, embeddingSourceHash);
         break;
       }
       case "deleted": {
@@ -2640,43 +2621,6 @@ class SyncService {
       }
     }
   }
-  async repairMissingEntityEmbeddings(options) {
-    if (!this.embeddingService) {
-      return 0;
-    }
-    const labelsToCheck = [...ENTITY_TYPES, "Document"];
-    const nodesWithMissingEmbeddings = await this.graph.findNodesWithMissingEmbeddings(labelsToCheck);
-    if (nodesWithMissingEmbeddings.length === 0) {
-      return 0;
-    }
-    if (options.verbose) {
-      this.logger.log(`Found ${nodesWithMissingEmbeddings.length} nodes with missing embeddings, repairing...`);
-    }
-    let repairedCount = 0;
-    for (const node of nodesWithMissingEmbeddings) {
-      try {
-        const text = node.label === "Document" ? node.name : composeEntityEmbeddingText({
-          type: node.label,
-          name: node.name,
-          description: node.description,
-          documentPaths: []
-        });
-        if (text.trim()) {
-          const embedding = await this.embeddingService.generateEmbedding(text);
-          await this.graph.updateNodeEmbedding(node.label, node.name, embedding);
-          repairedCount++;
-          this.logger.debug(`Repaired embedding for ${node.label}:${node.name}`);
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logger.warn(`Failed to repair embedding for ${node.label}:${node.name}: ${errorMessage}`);
-      }
-    }
-    if (options.verbose && repairedCount > 0) {
-      this.logger.log(`Repaired ${repairedCount} missing embeddings`);
-    }
-    return repairedCount;
-  }
 }
 SyncService = __legacyDecorateClassTS([
   Injectable11(),
@@ -2743,7 +2687,6 @@ class MigrateCommand extends CommandRunner3 {
         if (!options.dryRun) {
           const result = await this.syncService.sync({
             force: false,
-            useDbChangeDetection: true,
             aiExtraction: true,
             verbose: options.verbose,
             embeddings: true
@@ -3182,23 +3125,16 @@ import { Injectable as Injectable16 } from "@nestjs/common";
 import { Command as Command6, CommandRunner as CommandRunner6, Option as Option4 } from "nest-commander";
 class StatusCommand extends CommandRunner6 {
   syncService;
-  manifestService;
   dbChangeDetector;
-  constructor(syncService, manifestService, dbChangeDetector) {
+  constructor(syncService, dbChangeDetector) {
     super();
     this.syncService = syncService;
-    this.manifestService = manifestService;
     this.dbChangeDetector = dbChangeDetector;
   }
   async run(_inputs, options) {
     try {
-      const useDbDetection = !options.legacy;
-      if (useDbDetection) {
-        await this.dbChangeDetector.loadHashes();
-      } else {
-        await this.manifestService.load();
-      }
-      const changes = await this.syncService.detectChanges(undefined, useDbDetection);
+      await this.dbChangeDetector.loadHashes();
+      const changes = await this.syncService.detectChanges();
       const newDocs = changes.filter((c) => c.changeType === "new");
       const updatedDocs = changes.filter((c) => c.changeType === "updated");
       const deletedDocs = changes.filter((c) => c.changeType === "deleted");
@@ -3251,9 +3187,6 @@ class StatusCommand extends CommandRunner6 {
   parseVerbose() {
     return true;
   }
-  parseLegacy() {
-    return true;
-  }
 }
 __legacyDecorateClassTS([
   Option4({
@@ -3264,15 +3197,6 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
 ], StatusCommand.prototype, "parseVerbose", null);
-__legacyDecorateClassTS([
-  Option4({
-    flags: "--legacy",
-    description: "Use legacy v1 mode: manifest-based change detection"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], StatusCommand.prototype, "parseLegacy", null);
 StatusCommand = __legacyDecorateClassTS([
   Injectable16(),
   Command6({
@@ -3281,7 +3205,6 @@ StatusCommand = __legacyDecorateClassTS([
   }),
   __legacyMetadataTS("design:paramtypes", [
     typeof SyncService === "undefined" ? Object : SyncService,
-    typeof ManifestService === "undefined" ? Object : ManifestService,
     typeof DatabaseChangeDetectorService === "undefined" ? Object : DatabaseChangeDetectorService
   ])
 ], StatusCommand);
@@ -3486,7 +3409,6 @@ class SyncCommand extends CommandRunner7 {
       paths: paths.length > 0 ? paths : undefined,
       skipCascade: options.skipCascade,
       embeddings: options.embeddings !== false,
-      legacy: options.legacy,
       aiExtraction: !options.skipExtraction
     };
     console.log(`
@@ -3508,14 +3430,9 @@ class SyncCommand extends CommandRunner7 {
       console.log(`\uD83D\uDEAB Embedding generation disabled
 `);
     }
-    if (syncOptions.legacy) {
-      console.log(`\uD83D\uDCDC Legacy mode: Using manifest-based change detection
+    if (!syncOptions.aiExtraction) {
+      console.log(`\u23ED\uFE0F  AI entity extraction skipped (--skip-extraction)
 `);
-    } else {
-      if (!syncOptions.aiExtraction) {
-        console.log(`\u23ED\uFE0F  AI entity extraction skipped (--skip-extraction)
-`);
-      }
     }
     if (syncOptions.paths) {
       console.log(`\uD83D\uDCC1 Syncing specific paths: ${syncOptions.paths.join(", ")}
@@ -3713,9 +3630,6 @@ class SyncCommand extends CommandRunner7 {
   parseSkipExtraction() {
     return true;
   }
-  parseLegacy() {
-    return true;
-  }
 }
 __legacyDecorateClassTS([
   Option5({
@@ -3789,15 +3703,6 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:paramtypes", []),
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseSkipExtraction", null);
-__legacyDecorateClassTS([
-  Option5({
-    flags: "--legacy",
-    description: "Use legacy v1 mode: manifest-based change detection, no AI extraction"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseLegacy", null);
 SyncCommand = __legacyDecorateClassTS([
   Injectable18(),
   Command7({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zabaca/lattice",
-	"version": "1.0.20",
+	"version": "1.0.22",
 	"description": "Human-initiated, AI-powered knowledge graph for markdown documentation",
 	"type": "module",
 	"bin": {