@zabaca/lattice 1.0.4 → 1.0.6

package/dist/main.js

@@ -711,7 +711,14 @@ class VoyageEmbeddingProvider {
     const embeddings = await this.generateEmbeddings([text]);
     return embeddings[0];
   }
+  async generateQueryEmbedding(text) {
+    const embeddings = await this.generateEmbeddingsWithType([text], "query");
+    return embeddings[0];
+  }
   async generateEmbeddings(texts) {
+    return this.generateEmbeddingsWithType(texts, this.inputType);
+  }
+  async generateEmbeddingsWithType(texts, inputType) {
     if (!texts || texts.length === 0) {
       return [];
     }
@@ -726,7 +733,7 @@ class VoyageEmbeddingProvider {
           model: this.model,
           input: texts,
           output_dimension: this.dimensions,
-          input_type: this.inputType
+          input_type: inputType
         })
       });
       if (!response.ok) {
@@ -813,6 +820,15 @@ class EmbeddingService {
     }
     return this.provider.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);
+    }
+    return this.provider.generateEmbedding(text);
+  }
   async generateEmbeddings(texts) {
     const validTexts = texts.filter((t) => t && t.trim().length > 0);
     if (validTexts.length === 0) {
@@ -1234,7 +1250,7 @@ class SearchCommand extends CommandRunner3 {
     const query = inputs[0];
     const limit = Math.min(parseInt(options.limit || "20", 10), 100);
     try {
-      const queryEmbedding = await this.embeddingService.generateEmbedding(query);
+      const queryEmbedding = await this.embeddingService.generateQueryEmbedding(query);
       let results;
       if (options.label) {
         const labelResults = await this.graphService.vectorSearch(options.label, queryEmbedding, limit);
@@ -1570,6 +1586,46 @@ function collectUniqueEntities(docs) {
 // src/pure/validation.ts
 function validateDocuments(docs) {
   const errors = [];
+  for (const doc of docs) {
+    if (!doc.title || doc.title.trim() === "") {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: title"
+      });
+    }
+    if (!doc.summary || doc.summary.trim() === "") {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: summary"
+      });
+    }
+    if (!doc.created) {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: created"
+      });
+    }
+    if (!doc.updated) {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: updated"
+      });
+    }
+    if (!doc.status) {
+      errors.push({
+        path: doc.path,
+        error: "Missing required field: status"
+      });
+    }
+    for (const entity of doc.entities) {
+      if (!entity.description || entity.description.trim() === "") {
+        errors.push({
+          path: doc.path,
+          error: `Entity "${entity.name}" (${entity.type}) missing required field: description`
+        });
+      }
+    }
+  }
   const entityIndex = new Map;
   for (const doc of docs) {
     for (const entity of doc.entities) {
@@ -2485,15 +2541,175 @@ StatusCommand = __legacyDecorateClassTS([
 // src/commands/sync.command.ts
 import { watch } from "fs";
 import { join as join3 } from "path";
-import { Injectable as Injectable13 } from "@nestjs/common";
+import { Injectable as Injectable14 } from "@nestjs/common";
 import { Command as Command5, CommandRunner as CommandRunner5, Option as Option4 } from "nest-commander";
+
+// src/sync/graph-validator.service.ts
+import { Injectable as Injectable13, Logger as Logger6 } from "@nestjs/common";
+class GraphValidatorService {
+  graph;
+  logger = new Logger6(GraphValidatorService.name);
+  constructor(graph) {
+    this.graph = graph;
+  }
+  async validateGraph() {
+    const issues = [];
+    let totalNodes = 0;
+    let documentsChecked = 0;
+    let entitiesChecked = 0;
+    try {
+      const result = await this.graph.query("SELECT label, name, properties FROM nodes");
+      totalNodes = result.resultSet.length;
+      for (const row of result.resultSet) {
+        const label = row[0];
+        const name = row[1];
+        const propertiesJson = row[2];
+        let properties;
+        try {
+          properties = typeof propertiesJson === "string" ? JSON.parse(propertiesJson) : propertiesJson;
+        } catch (_error) {
+          issues.push({
+            type: "error",
+            nodeLabel: label,
+            nodeName: name,
+            field: "properties",
+            message: "Invalid JSON in properties field",
+            suggestion: "Re-sync this document to fix corrupted data"
+          });
+          continue;
+        }
+        if (label === "Document") {
+          documentsChecked++;
+          this.validateDocumentNode(name, properties, issues);
+        } else {
+          entitiesChecked++;
+          this.validateEntityNode(label, name, properties, issues);
+        }
+      }
+    } catch (error) {
+      this.logger.error(`Graph validation failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+    const errorsFound = issues.filter((i) => i.type === "error").length;
+    const warningsFound = issues.filter((i) => i.type === "warning").length;
+    return {
+      valid: errorsFound === 0,
+      issues,
+      stats: {
+        totalNodes,
+        documentsChecked,
+        entitiesChecked,
+        errorsFound,
+        warningsFound
+      }
+    };
+  }
+  validateDocumentNode(name, properties, issues) {
+    if ("name" in properties) {
+      issues.push({
+        type: "warning",
+        nodeLabel: "Document",
+        nodeName: name,
+        field: "name",
+        message: "Duplicate 'name' field in properties (already in column)",
+        suggestion: "Re-sync to remove duplicate"
+      });
+    }
+    const requiredFields = ["title", "contentHash"];
+    for (const field of requiredFields) {
+      if (!(field in properties)) {
+        issues.push({
+          type: "error",
+          nodeLabel: "Document",
+          nodeName: name,
+          field,
+          message: `Missing required field: ${field}`,
+          suggestion: "Re-sync this document to populate required fields"
+        });
+      }
+    }
+    const recommendedFields = ["summary", "created", "updated", "status"];
+    for (const field of recommendedFields) {
+      if (!(field in properties)) {
+        issues.push({
+          type: "warning",
+          nodeLabel: "Document",
+          nodeName: name,
+          field,
+          message: `Missing recommended field: ${field}`,
+          suggestion: `Add '${field}' to document frontmatter`
+        });
+      }
+    }
+  }
+  validateEntityNode(label, name, properties, issues) {
+    if ("name" in properties) {
+      issues.push({
+        type: "warning",
+        nodeLabel: label,
+        nodeName: name,
+        field: "name",
+        message: "Duplicate 'name' field in properties (already in column)",
+        suggestion: "Re-sync to remove duplicate"
+      });
+    }
+    if (!("description" in properties) || !properties.description) {
+      issues.push({
+        type: "error",
+        nodeLabel: label,
+        nodeName: name,
+        field: "description",
+        message: "Missing required field: description",
+        suggestion: `Add description to ${label} entity in frontmatter`
+      });
+    }
+  }
+  async validateDocument(path2) {
+    const issues = [];
+    try {
+      const result = await this.graph.query(`SELECT label, name, properties FROM nodes WHERE label = 'Document' AND name = '${this.escape(path2)}'`);
+      if (result.resultSet.length === 0) {
+        issues.push({
+          type: "error",
+          nodeLabel: "Document",
+          nodeName: path2,
+          field: "node",
+          message: "Document not found in graph",
+          suggestion: "Run 'lattice sync' to add this document"
+        });
+        return issues;
+      }
+      const row = result.resultSet[0];
+      const propertiesJson = row[2];
+      const properties = typeof propertiesJson === "string" ? JSON.parse(propertiesJson) : propertiesJson;
+      this.validateDocumentNode(path2, properties, issues);
+    } catch (error) {
+      this.logger.error(`Failed to validate document ${path2}: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+    return issues;
+  }
+  escape(value) {
+    return value.replace(/'/g, "''");
+  }
+}
+GraphValidatorService = __legacyDecorateClassTS([
+  Injectable13(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof GraphService === "undefined" ? Object : GraphService
+  ])
+], GraphValidatorService);
+
+// src/commands/sync.command.ts
 class SyncCommand extends CommandRunner5 {
   syncService;
+  _graphValidator;
   watcher = null;
   isShuttingDown = false;
-  constructor(syncService) {
+  constructor(syncService, _graphValidator) {
     super();
     this.syncService = syncService;
+    this._graphValidator = _graphValidator;
   }
   async run(paths, options) {
     if (options.watch && options.dryRun) {
@@ -2651,22 +2867,25 @@ class SyncCommand extends CommandRunner5 {
       });
     }
     if (result.changes && result.changes.length > 0) {
-      console.log(`
+      const actualChanges = result.changes.filter((c) => c.changeType !== "unchanged");
+      if (actualChanges.length > 0) {
+        console.log(`
 \uD83D\uDCDD Changes:
 `);
-      const icons = {
-        new: "\u2795",
-        updated: "\uD83D\uDD04",
-        deleted: "\uD83D\uDDD1\uFE0F",
-        unchanged: "\u23ED\uFE0F"
-      };
-      result.changes.forEach((c) => {
-        const icon = icons[c.changeType];
-        console.log(`  ${icon} ${c.changeType}: ${c.path}`);
-        if (c.reason) {
-          console.log(`     ${c.reason}`);
-        }
-      });
+        const icons = {
+          new: "\u2795",
+          updated: "\uD83D\uDD04",
+          deleted: "\uD83D\uDDD1\uFE0F",
+          unchanged: "\u23ED\uFE0F"
+        };
+        actualChanges.forEach((c) => {
+          const icon = icons[c.changeType];
+          console.log(`  ${icon} ${c.changeType}: ${c.path}`);
+          if (c.reason) {
+            console.log(`     ${c.reason}`);
+          }
+        });
+      }
     }
     if (result.cascadeWarnings && result.cascadeWarnings.length > 0) {
       console.log(`
@@ -2795,28 +3014,31 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], SyncCommand.prototype, "parseNoEmbeddings", null);
 SyncCommand = __legacyDecorateClassTS([
-  Injectable13(),
+  Injectable14(),
   Command5({
     name: "sync",
     arguments: "[paths...]",
     description: "Synchronize documents to the knowledge graph"
   }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof SyncService === "undefined" ? Object : SyncService
+    typeof SyncService === "undefined" ? Object : SyncService,
+    typeof GraphValidatorService === "undefined" ? Object : GraphValidatorService
   ])
 ], SyncCommand);
 // src/commands/validate.command.ts
-import { Injectable as Injectable14 } from "@nestjs/common";
+import { Injectable as Injectable15 } from "@nestjs/common";
 import { Command as Command6, CommandRunner as CommandRunner6, Option as Option5 } from "nest-commander";
 class ValidateCommand extends CommandRunner6 {
   parserService;
-  constructor(parserService) {
+  _graphValidator;
+  constructor(parserService, _graphValidator) {
     super();
     this.parserService = parserService;
+    this._graphValidator = _graphValidator;
   }
   async run(_inputs, options) {
     try {
-      console.log(`Validating entities and relationships...
+      console.log(`=== Document Validation ===
 `);
       const { docs, errors: schemaErrors } = await this.parserService.parseAllDocumentsWithErrors();
       const issues = [];
@@ -2851,7 +3073,7 @@ class ValidateCommand extends CommandRunner6 {
       console.log(`Found ${entityIndex.size} unique entities
 `);
       if (issues.length > 0) {
-        console.log(`Errors (${issues.length}):
+        console.log(`Document Errors (${issues.length}):
 `);
         issues.forEach((i) => {
           console.log(`  ${i.path}`);
@@ -2861,11 +3083,32 @@ class ValidateCommand extends CommandRunner6 {
           }
           console.log("");
         });
+      } else {
+        console.log(`\u2713 Markdown files valid (schema + relationships)
+`);
       }
-      if (issues.length === 0) {
-        console.log("All validations passed!");
-      }
-      process.exit(issues.length > 0 ? 1 : 0);
+      const graphResult = {
+        valid: true,
+        issues: [],
+        stats: {
+          totalNodes: 0,
+          documentsChecked: 0,
+          entitiesChecked: 0,
+          errorsFound: 0,
+          warningsFound: 0
+        }
+      };
+      const totalErrors = issues.length + graphResult.stats.errorsFound;
+      const totalWarnings = graphResult.stats.warningsFound;
+      console.log(`
+=== Validation Summary ===`);
+      console.log(`Markdown files: ${issues.length === 0 ? "\u2713 PASSED" : `\u2717 ${issues.length} errors`}`);
+      console.log(`Graph database: ${graphResult.stats.errorsFound === 0 ? "\u2713 PASSED" : `\u2717 ${graphResult.stats.errorsFound} errors`}`);
+      console.log(`Warnings: ${totalWarnings}`);
+      console.log(`
+Overall: ${totalErrors === 0 ? "\u2713 PASSED" : "\u2717 FAILED"}${totalWarnings > 0 ? ` (${totalWarnings} warnings)` : ""}
+`);
+      process.exit(totalErrors > 0 ? 1 : 0);
     } catch (error) {
       console.error("Validation failed:", error instanceof Error ? error.message : String(error));
       process.exit(1);
@@ -2885,13 +3128,14 @@ __legacyDecorateClassTS([
   __legacyMetadataTS("design:returntype", Boolean)
 ], ValidateCommand.prototype, "parseFix", null);
 ValidateCommand = __legacyDecorateClassTS([
-  Injectable14(),
+  Injectable15(),
   Command6({
     name: "validate",
     description: "Validate entity references and relationships across documents"
   }),
   __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
+    typeof DocumentParserService === "undefined" ? Object : DocumentParserService,
+    typeof GraphValidatorService === "undefined" ? Object : GraphValidatorService
   ])
 ], ValidateCommand);
 // src/embedding/embedding.module.ts
@@ -2922,10 +3166,10 @@ GraphModule = __legacyDecorateClassTS([
 import { Module as Module3 } from "@nestjs/common";
 
 // src/query/query.service.ts
-import { Injectable as Injectable15, Logger as Logger6 } from "@nestjs/common";
+import { Injectable as Injectable16, Logger as Logger7 } from "@nestjs/common";
 class QueryService {
   graphService;
-  logger = new Logger6(QueryService.name);
+  logger = new Logger7(QueryService.name);
   constructor(graphService) {
     this.graphService = graphService;
   }
@@ -2935,7 +3179,7 @@ class QueryService {
   }
 }
 QueryService = __legacyDecorateClassTS([
-  Injectable15(),
+  Injectable16(),
   __legacyMetadataTS("design:paramtypes", [
     typeof GraphService === "undefined" ? Object : GraphService
   ])
@@ -2965,7 +3209,8 @@ SyncModule = __legacyDecorateClassTS([
       DocumentParserService,
       OntologyService,
       CascadeService,
-      PathResolverService
+      PathResolverService,
+      GraphValidatorService
     ],
     exports: [
       SyncService,
@@ -2973,7 +3218,8 @@ SyncModule = __legacyDecorateClassTS([
       DocumentParserService,
       OntologyService,
       CascadeService,
-      PathResolverService
+      PathResolverService,
+      GraphValidatorService
     ]
   })
 ], SyncModule);

package/package.json

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