@zabaca/lattice 1.0.9 → 1.0.10

package/dist/cli.js

@@ -1,3035 +0,0 @@
-#!/usr/bin/env node
-// @bun
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __legacyMetadataTS = (k, v) => {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-
-// src/main.ts
-import"reflect-metadata";
-import { CommandFactory } from "nest-commander";
-
-// src/app.module.ts
-import { Module as Module5 } from "@nestjs/common";
-import { ConfigModule as ConfigModule2 } from "@nestjs/config";
-
-// src/graph/graph.module.ts
-import { Module } from "@nestjs/common";
-
-// src/graph/graph.service.ts
-import { Injectable, Logger } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-import Redis from "ioredis";
-class GraphService {
-  configService;
-  logger = new Logger(GraphService.name);
-  redis = null;
-  config;
-  connecting = null;
-  constructor(configService) {
-    this.configService = configService;
-    this.config = {
-      host: this.configService.get("FALKORDB_HOST", "localhost"),
-      port: this.configService.get("FALKORDB_PORT", 6379),
-      graphName: this.configService.get("GRAPH_NAME", "research_knowledge")
-    };
-  }
-  async onModuleDestroy() {
-    await this.disconnect();
-  }
-  async ensureConnected() {
-    if (this.redis) {
-      return this.redis;
-    }
-    if (this.connecting) {
-      await this.connecting;
-      return this.redis;
-    }
-    this.connecting = this.connect();
-    await this.connecting;
-    this.connecting = null;
-    return this.redis;
-  }
-  async connect() {
-    try {
-      this.redis = new Redis({
-        host: this.config.host,
-        port: this.config.port,
-        maxRetriesPerRequest: 3,
-        retryStrategy: (times) => {
-          if (times > 3) {
-            return null;
-          }
-          const delay = Math.min(times * 50, 2000);
-          return delay;
-        },
-        lazyConnect: true
-      });
-      this.redis.on("error", (err) => {
-        this.logger.debug(`Redis connection error: ${err.message}`);
-      });
-      await this.redis.ping();
-      this.logger.log(`Connected to FalkorDB at ${this.config.host}:${this.config.port}`);
-    } catch (error) {
-      this.redis = null;
-      this.logger.error(`Failed to connect to FalkorDB: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async disconnect() {
-    if (this.redis) {
-      await this.redis.quit();
-      this.logger.log("Disconnected from FalkorDB");
-    }
-  }
-  async query(cypher, _params) {
-    try {
-      const redis = await this.ensureConnected();
-      const result = await redis.call("GRAPH.QUERY", this.config.graphName, cypher);
-      const resultArray = Array.isArray(result) ? result : [];
-      return {
-        resultSet: Array.isArray(resultArray[1]) ? resultArray[1] : [],
-        stats: this.parseStats(result)
-      };
-    } catch (error) {
-      this.logger.error(`Cypher query failed: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async getStats() {
-    try {
-      const labels = await this.getLabels();
-      const relationshipTypes = await this.getRelationshipTypes();
-      const nodeCountResult = await this.query("MATCH (n) RETURN count(n) as count");
-      const nodeCount = nodeCountResult.resultSet?.[0]?.[0] || 0;
-      const edgeCountResult = await this.query("MATCH ()-[r]-() RETURN count(r) as count");
-      const edgeCount = edgeCountResult.resultSet?.[0]?.[0] || 0;
-      const entityCounts = {};
-      for (const label of labels) {
-        const result = await this.query(`MATCH (n:\`${label}\`) RETURN count(n) as count`);
-        entityCounts[label] = result.resultSet?.[0]?.[0] || 0;
-      }
-      const relationshipCounts = {};
-      for (const relType of relationshipTypes) {
-        const result = await this.query(`MATCH ()-[r:\`${relType}\`]-() RETURN count(r) as count`);
-        relationshipCounts[relType] = result.resultSet?.[0]?.[0] || 0;
-      }
-      return {
-        nodeCount,
-        edgeCount,
-        labels,
-        relationshipTypes,
-        entityCounts,
-        relationshipCounts
-      };
-    } catch (error) {
-      this.logger.error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async getLabels() {
-    try {
-      const result = await this.query("CALL db.labels() YIELD label RETURN label");
-      return (result.resultSet || []).map((row) => row[0]);
-    } catch (error) {
-      this.logger.error(`Failed to get labels: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async getRelationshipTypes() {
-    try {
-      const result = await this.query("CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType");
-      return (result.resultSet || []).map((row) => row[0]);
-    } catch (error) {
-      this.logger.error(`Failed to get relationship types: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async upsertNode(label, properties) {
-    try {
-      const { name, ...otherProps } = properties;
-      if (!name) {
-        throw new Error("Node must have a 'name' property");
-      }
-      const escapedName = this.escapeCypher(String(name));
-      const escapedLabel = this.escapeCypher(label);
-      const propAssignments = Object.entries({
-        name,
-        ...otherProps
-      }).map(([key, value]) => {
-        const escapedKey = this.escapeCypher(key);
-        const escapedValue = this.escapeCypherValue(value);
-        return `n.\`${escapedKey}\` = ${escapedValue}`;
-      }).join(", ");
-      const cypher = `MERGE (n:\`${escapedLabel}\` { name: '${escapedName}' }) ` + `SET ${propAssignments}`;
-      await this.query(cypher);
-    } catch (error) {
-      this.logger.error(`Failed to upsert node: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async upsertRelationship(sourceLabel, sourceName, relation, targetLabel, targetName, properties) {
-    try {
-      const escapedSourceLabel = this.escapeCypher(sourceLabel);
-      const escapedSourceName = this.escapeCypher(sourceName);
-      const escapedRelation = this.escapeCypher(relation);
-      const escapedTargetLabel = this.escapeCypher(targetLabel);
-      const escapedTargetName = this.escapeCypher(targetName);
-      let relPropAssignments = "";
-      if (properties && Object.keys(properties).length > 0) {
-        relPropAssignments = ` SET ` + Object.entries(properties).map(([key, value]) => {
-          const escapedKey = this.escapeCypher(key);
-          const escapedValue = this.escapeCypherValue(value);
-          return `r.\`${escapedKey}\` = ${escapedValue}`;
-        }).join(", ");
-      }
-      const cypher = `MERGE (source:\`${escapedSourceLabel}\` { name: '${escapedSourceName}' }) ` + `MERGE (target:\`${escapedTargetLabel}\` { name: '${escapedTargetName}' }) ` + `MERGE (source)-[r:\`${escapedRelation}\`]->(target)` + relPropAssignments;
-      await this.query(cypher);
-    } catch (error) {
-      this.logger.error(`Failed to upsert relationship: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async deleteNode(label, name) {
-    try {
-      const escapedLabel = this.escapeCypher(label);
-      const escapedName = this.escapeCypher(name);
-      const cypher = `MATCH (n:\`${escapedLabel}\` { name: '${escapedName}' }) ` + `DETACH DELETE n`;
-      await this.query(cypher);
-    } catch (error) {
-      this.logger.error(`Failed to delete node: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async deleteDocumentRelationships(documentPath) {
-    try {
-      const escapedPath = this.escapeCypher(documentPath);
-      const cypher = `MATCH ()-[r { documentPath: '${escapedPath}' }]-() ` + `DELETE r`;
-      await this.query(cypher);
-    } catch (error) {
-      this.logger.error(`Failed to delete document relationships: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async findNodesByLabel(label, limit) {
-    try {
-      const escapedLabel = this.escapeCypher(label);
-      const limitClause = limit ? ` LIMIT ${limit}` : "";
-      const cypher = `MATCH (n:\`${escapedLabel}\`) RETURN n${limitClause}`;
-      const result = await this.query(cypher);
-      return (result.resultSet || []).map((row) => row[0]);
-    } catch (error) {
-      this.logger.error(`Failed to find nodes by label: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async findRelationships(nodeName) {
-    try {
-      const escapedName = this.escapeCypher(nodeName);
-      const cypher = `MATCH (n { name: '${escapedName}' })-[r]-(m) ` + `RETURN type(r), m.name`;
-      const result = await this.query(cypher);
-      return result.resultSet || [];
-    } catch (error) {
-      this.logger.error(`Failed to find relationships: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async createVectorIndex(label, property, dimensions) {
-    try {
-      const escapedLabel = this.escapeCypher(label);
-      const escapedProperty = this.escapeCypher(property);
-      const cypher = `CREATE VECTOR INDEX FOR (n:\`${escapedLabel}\`) ON (n.\`${escapedProperty}\`) OPTIONS { dimension: ${dimensions}, similarityFunction: 'cosine' }`;
-      await this.query(cypher);
-      this.logger.log(`Created vector index on ${label}.${property} with ${dimensions} dimensions`);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (!errorMessage.includes("already indexed")) {
-        this.logger.error(`Failed to create vector index: ${errorMessage}`);
-        throw error;
-      }
-      this.logger.debug(`Vector index on ${label}.${property} already exists`);
-    }
-  }
-  async updateNodeEmbedding(label, name, embedding) {
-    try {
-      const escapedLabel = this.escapeCypher(label);
-      const escapedName = this.escapeCypher(name);
-      const vectorStr = `[${embedding.join(", ")}]`;
-      const cypher = `MATCH (n:\`${escapedLabel}\` { name: '${escapedName}' }) ` + `SET n.embedding = vecf32(${vectorStr})`;
-      await this.query(cypher);
-    } catch (error) {
-      this.logger.error(`Failed to update node embedding: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async vectorSearch(label, queryVector, k = 10) {
-    try {
-      const escapedLabel = this.escapeCypher(label);
-      const vectorStr = `[${queryVector.join(", ")}]`;
-      const cypher = `CALL db.idx.vector.queryNodes('${escapedLabel}', 'embedding', ${k}, vecf32(${vectorStr})) ` + `YIELD node, score ` + `RETURN node.name AS name, node.title AS title, (2 - score) / 2 AS similarity ` + `ORDER BY similarity DESC`;
-      const result = await this.query(cypher);
-      return (result.resultSet || []).map((row) => ({
-        name: row[0],
-        title: row[1],
-        score: row[2]
-      }));
-    } catch (error) {
-      this.logger.error(`Vector search failed: ${error instanceof Error ? error.message : String(error)}`);
-      throw error;
-    }
-  }
-  async vectorSearchAll(queryVector, k = 10) {
-    const allLabels = ["Document", "Concept", "Process", "Tool", "Technology", "Organization", "Topic", "Person"];
-    const allResults = [];
-    for (const label of allLabels) {
-      try {
-        const escapedLabel = this.escapeCypher(label);
-        const vectorStr = `[${queryVector.join(", ")}]`;
-        const cypher = `CALL db.idx.vector.queryNodes('${escapedLabel}', 'embedding', ${k}, vecf32(${vectorStr})) ` + `YIELD node, score ` + `RETURN node.name AS name, node.title AS title, node.description AS description, (2 - score) / 2 AS similarity ` + `ORDER BY similarity DESC`;
-        const result = await this.query(cypher);
-        const labelResults = (result.resultSet || []).map((row) => ({
-          name: row[0],
-          label,
-          title: row[1],
-          description: row[2],
-          score: row[3]
-        }));
-        allResults.push(...labelResults);
-      } catch (error) {
-        this.logger.debug(`Vector search for ${label} skipped: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-    return allResults.sort((a, b) => b.score - a.score).slice(0, k);
-  }
-  escapeCypher(value) {
-    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"");
-  }
-  escapeCypherValue(value) {
-    if (value === null || value === undefined) {
-      return "null";
-    }
-    if (typeof value === "string") {
-      const escaped = this.escapeCypher(value);
-      return `'${escaped}'`;
-    }
-    if (typeof value === "number" || typeof value === "boolean") {
-      return String(value);
-    }
-    if (Array.isArray(value)) {
-      return `[${value.map((v) => this.escapeCypherValue(v)).join(", ")}]`;
-    }
-    if (typeof value === "object") {
-      const pairs = Object.entries(value).map(([k, v]) => `${k}: ${this.escapeCypherValue(v)}`).join(", ");
-      return `{${pairs}}`;
-    }
-    return String(value);
-  }
-  parseStats(result) {
-    if (!Array.isArray(result) || result.length < 3) {
-      return;
-    }
-    const statsStr = result[2];
-    if (!statsStr || typeof statsStr !== "string") {
-      return;
-    }
-    const stats = {
-      nodesCreated: 0,
-      nodesDeleted: 0,
-      relationshipsCreated: 0,
-      relationshipsDeleted: 0,
-      propertiesSet: 0
-    };
-    const nodeCreatedMatch = statsStr.match(/Nodes created: (\d+)/);
-    if (nodeCreatedMatch) {
-      stats.nodesCreated = parseInt(nodeCreatedMatch[1], 10);
-    }
-    const nodeDeletedMatch = statsStr.match(/Nodes deleted: (\d+)/);
-    if (nodeDeletedMatch) {
-      stats.nodesDeleted = parseInt(nodeDeletedMatch[1], 10);
-    }
-    const relCreatedMatch = statsStr.match(/Relationships created: (\d+)/);
-    if (relCreatedMatch) {
-      stats.relationshipsCreated = parseInt(relCreatedMatch[1], 10);
-    }
-    const relDeletedMatch = statsStr.match(/Relationships deleted: (\d+)/);
-    if (relDeletedMatch) {
-      stats.relationshipsDeleted = parseInt(relDeletedMatch[1], 10);
-    }
-    const propSetMatch = statsStr.match(/Properties set: (\d+)/);
-    if (propSetMatch) {
-      stats.propertiesSet = parseInt(propSetMatch[1], 10);
-    }
-    return stats;
-  }
-}
-GraphService = __legacyDecorateClassTS([
-  Injectable(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof ConfigService === "undefined" ? Object : ConfigService
-  ])
-], GraphService);
-
-// src/graph/graph.module.ts
-class GraphModule {
-}
-GraphModule = __legacyDecorateClassTS([
-  Module({
-    providers: [GraphService],
-    exports: [GraphService]
-  })
-], GraphModule);
-
-// src/sync/sync.module.ts
-import { Module as Module3 } from "@nestjs/common";
-
-// src/sync/sync.service.ts
-import { Injectable as Injectable7, Logger as Logger6 } from "@nestjs/common";
-
-// src/sync/manifest.service.ts
-import { Injectable as Injectable2 } from "@nestjs/common";
-import { createHash } from "crypto";
-import { readFile, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { resolve } from "path";
-function getProjectRoot() {
-  if (process.env.PROJECT_ROOT) {
-    return process.env.PROJECT_ROOT;
-  }
-  return process.cwd();
-}
-
-class ManifestService {
-  manifestPath;
-  manifest = null;
-  constructor() {
-    const docsPath = process.env.DOCS_PATH || "docs";
-    this.manifestPath = resolve(getProjectRoot(), docsPath, ".sync-manifest.json");
-  }
-  async load() {
-    try {
-      if (existsSync(this.manifestPath)) {
-        const content = await readFile(this.manifestPath, "utf-8");
-        this.manifest = JSON.parse(content);
-      } else {
-        this.manifest = this.createEmptyManifest();
-      }
-    } catch (error) {
-      this.manifest = this.createEmptyManifest();
-    }
-    return this.manifest;
-  }
-  async save() {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    this.manifest.lastSync = new Date().toISOString();
-    const content = JSON.stringify(this.manifest, null, 2);
-    await writeFile(this.manifestPath, content, "utf-8");
-  }
-  getContentHash(content) {
-    return createHash("sha256").update(content).digest("hex");
-  }
-  detectChange(path, contentHash, frontmatterHash) {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    const existing = this.manifest.documents[path];
-    if (!existing) {
-      return "new";
-    }
-    if (existing.contentHash === contentHash && existing.frontmatterHash === frontmatterHash) {
-      return "unchanged";
-    }
-    return "updated";
-  }
-  updateEntry(path, contentHash, frontmatterHash, entityCount, relationshipCount) {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    this.manifest.documents[path] = {
-      contentHash,
-      frontmatterHash,
-      lastSynced: new Date().toISOString(),
-      entityCount,
-      relationshipCount
-    };
-  }
-  removeEntry(path) {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    delete this.manifest.documents[path];
-  }
-  getTrackedPaths() {
-    if (!this.manifest) {
-      throw new Error("Manifest not loaded. Call load() first.");
-    }
-    return Object.keys(this.manifest.documents);
-  }
-  createEmptyManifest() {
-    return {
-      version: "1.0",
-      lastSync: new Date().toISOString(),
-      documents: {}
-    };
-  }
-}
-ManifestService = __legacyDecorateClassTS([
-  Injectable2(),
-  __legacyMetadataTS("design:paramtypes", [])
-], ManifestService);
-
-// src/sync/document-parser.service.ts
-import { Injectable as Injectable3, Logger as Logger2 } from "@nestjs/common";
-import { glob } from "glob";
-import { readFile as readFile2 } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
-import { resolve as resolve2 } from "path";
-
-// src/utils/frontmatter.ts
-import { z } from "zod";
-import matter from "gray-matter";
-var EntityTypeSchema = z.enum([
-  "Topic",
-  "Technology",
-  "Concept",
-  "Tool",
-  "Process",
-  "Person",
-  "Organization",
-  "Document"
-]);
-var RelationTypeSchema = z.enum([
-  "REFERENCES"
-]);
-var EntitySchema = z.object({
-  name: z.string().min(1),
-  type: EntityTypeSchema,
-  description: z.string().optional()
-});
-var RelationshipSchema = z.object({
-  source: z.string().min(1),
-  relation: RelationTypeSchema,
-  target: z.string().min(1)
-});
-var GraphMetadataSchema = z.object({
-  importance: z.enum(["high", "medium", "low"]).optional(),
-  domain: z.string().optional()
-});
-var validateDateFormat = (dateStr) => {
-  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (!match)
-    return false;
-  const [, yearStr, monthStr, dayStr] = match;
-  const year = parseInt(yearStr, 10);
-  const month = parseInt(monthStr, 10);
-  const day = parseInt(dayStr, 10);
-  if (month < 1 || month > 12)
-    return false;
-  if (day < 1 || day > 31)
-    return false;
-  const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-  if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {
-    daysInMonth[1] = 29;
-  }
-  return day <= daysInMonth[month - 1];
-};
-var FrontmatterSchema = z.object({
-  created: z.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
-  updated: z.string().refine(validateDateFormat, "Date must be in YYYY-MM-DD format"),
-  status: z.enum(["draft", "ongoing", "complete"]).optional(),
-  topic: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  summary: z.string().optional(),
-  entities: z.array(EntitySchema).optional(),
-  relationships: z.array(RelationshipSchema).optional(),
-  graph: GraphMetadataSchema.optional()
-}).passthrough();
-function parseFrontmatter(content) {
-  try {
-    const { data, content: markdown } = matter(content);
-    if (Object.keys(data).length === 0) {
-      return {
-        frontmatter: null,
-        content: markdown.trim(),
-        raw: content
-      };
-    }
-    const normalizedData = normalizeData(data);
-    const validated = FrontmatterSchema.safeParse(normalizedData);
-    return {
-      frontmatter: validated.success ? validated.data : normalizedData,
-      content: markdown.trim(),
-      raw: content
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`YAML parsing error: ${errorMessage}`);
-  }
-}
-function normalizeData(data) {
-  if (data instanceof Date) {
-    return data.toISOString().split("T")[0];
-  }
-  if (Array.isArray(data)) {
-    return data.map(normalizeData);
-  }
-  if (data !== null && typeof data === "object") {
-    const normalized = {};
-    for (const [key, value] of Object.entries(data)) {
-      normalized[key] = normalizeData(value);
-    }
-    return normalized;
-  }
-  return data;
-}
-
-// src/sync/document-parser.service.ts
-function getProjectRoot2() {
-  if (process.env.PROJECT_ROOT) {
-    return process.env.PROJECT_ROOT;
-  }
-  return process.cwd();
-}
-
-class DocumentParserService {
-  logger = new Logger2(DocumentParserService.name);
-  docsPath;
-  constructor() {
-    const docsPathEnv = process.env.DOCS_PATH || "docs";
-    if (docsPathEnv.startsWith("/")) {
-      this.docsPath = docsPathEnv;
-    } else {
-      this.docsPath = resolve2(getProjectRoot2(), docsPathEnv);
-    }
-  }
-  getDocsPath() {
-    return this.docsPath;
-  }
-  async discoverDocuments() {
-    const pattern = `${this.docsPath}/**/*.md`;
-    const files = await glob(pattern, {
-      ignore: ["**/node_modules/**", "**/.git/**"]
-    });
-    return files.sort();
-  }
-  async parseDocument(filePath) {
-    const content = await readFile2(filePath, "utf-8");
-    const parsed = parseFrontmatter(content);
-    const title = this.extractTitle(content, filePath);
-    const contentHash = this.computeHash(content);
-    const frontmatterHash = this.computeHash(JSON.stringify(parsed.frontmatter || {}));
-    const entities = this.extractEntities(parsed.frontmatter, filePath);
-    const relationships = this.extractRelationships(parsed.frontmatter, filePath);
-    const graphMetadata = this.extractGraphMetadata(parsed.frontmatter);
-    return {
-      path: filePath,
-      title,
-      content: parsed.content,
-      contentHash,
-      frontmatterHash,
-      summary: parsed.frontmatter?.summary,
-      topic: parsed.frontmatter?.topic,
-      entities,
-      relationships,
-      graphMetadata,
-      tags: parsed.frontmatter?.tags || [],
-      created: parsed.frontmatter?.created,
-      updated: parsed.frontmatter?.updated,
-      status: parsed.frontmatter?.status
-    };
-  }
-  async parseAllDocuments() {
-    const { docs } = await this.parseAllDocumentsWithErrors();
-    return docs;
-  }
-  async parseAllDocumentsWithErrors() {
-    const files = await this.discoverDocuments();
-    const docs = [];
-    const errors = [];
-    for (const file of files) {
-      try {
-        const parsed = await this.parseDocument(file);
-        docs.push(parsed);
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        errors.push({ path: file, error: errorMsg });
-        this.logger.warn(`Failed to parse ${file}: ${error}`);
-      }
-    }
-    return { docs, errors };
-  }
-  extractTitle(content, filePath) {
-    const h1Match = content.match(/^#\s+(.+)$/m);
-    if (h1Match) {
-      return h1Match[1];
-    }
-    const parts = filePath.split("/");
-    return parts[parts.length - 1].replace(".md", "");
-  }
-  extractEntities(frontmatter, docPath) {
-    if (!frontmatter?.entities || !Array.isArray(frontmatter.entities)) {
-      return [];
-    }
-    const validEntities = [];
-    const errors = [];
-    for (let i = 0;i < frontmatter.entities.length; i++) {
-      const e = frontmatter.entities[i];
-      const result = EntitySchema.safeParse(e);
-      if (result.success) {
-        validEntities.push(result.data);
-      } else {
-        const entityPreview = typeof e === "string" ? `"${e}"` : JSON.stringify(e);
-        errors.push(`Entity[${i}]: ${entityPreview} - Expected object with {name, type}, got ${typeof e}`);
-      }
-    }
-    if (errors.length > 0) {
-      const errorMsg = `Invalid entity schema in ${docPath}:
-  ${errors.join(`
-  `)}`;
-      throw new Error(errorMsg);
-    }
-    return validEntities;
-  }
-  extractRelationships(frontmatter, docPath) {
-    if (!frontmatter?.relationships || !Array.isArray(frontmatter.relationships)) {
-      return [];
-    }
-    const validRelationships = [];
-    const errors = [];
-    const validRelationTypes = RelationTypeSchema.options;
-    for (let i = 0;i < frontmatter.relationships.length; i++) {
-      const r = frontmatter.relationships[i];
-      const result = RelationshipSchema.safeParse(r);
-      if (result.success) {
-        const rel = result.data;
-        if (rel.source === "this") {
-          rel.source = docPath;
-        }
-        if (rel.target === "this") {
-          rel.target = docPath;
-        }
-        validRelationships.push(rel);
-      } else {
-        if (typeof r === "string") {
-          errors.push(`Relationship[${i}]: "${r}" - Expected object with {source, relation, target}, got string`);
-        } else if (typeof r === "object" && r !== null) {
-          const issues = [];
-          if (!r.source)
-            issues.push("missing source");
-          if (!r.target)
-            issues.push("missing target");
-          if (!r.relation) {
-            issues.push("missing relation");
-          } else if (!validRelationTypes.includes(r.relation)) {
-            issues.push(`invalid relation "${r.relation}" (allowed: ${validRelationTypes.join(", ")})`);
-          }
-          errors.push(`Relationship[${i}]: ${issues.join(", ")}`);
-        } else {
-          errors.push(`Relationship[${i}]: Expected object, got ${typeof r}`);
-        }
-      }
-    }
-    if (errors.length > 0) {
-      const errorMsg = `Invalid relationship schema in ${docPath}:
-  ${errors.join(`
-  `)}`;
-      throw new Error(errorMsg);
-    }
-    return validRelationships;
-  }
-  extractGraphMetadata(frontmatter) {
-    if (!frontmatter?.graph) {
-      return;
-    }
-    const result = GraphMetadataSchema.safeParse(frontmatter.graph);
-    return result.success ? result.data : undefined;
-  }
-  computeHash(content) {
-    return createHash2("sha256").update(content).digest("hex");
-  }
-}
-DocumentParserService = __legacyDecorateClassTS([
-  Injectable3(),
-  __legacyMetadataTS("design:paramtypes", [])
-], DocumentParserService);
-
-// src/sync/cascade.service.ts
-import { Injectable as Injectable4, Logger as Logger3 } from "@nestjs/common";
-class CascadeService {
-  graph;
-  _parser;
-  logger = new Logger3(CascadeService.name);
-  constructor(graph, _parser) {
-    this.graph = graph;
-    this._parser = _parser;
-  }
-  async analyzeEntityChange(change) {
-    let affectedDocuments = [];
-    let summary;
-    switch (change.trigger) {
-      case "entity_renamed":
-        affectedDocuments = await this.findAffectedByRename(change.entityName, change.newValue || "");
-        summary = `Entity "${change.oldValue}" was renamed to "${change.newValue}"`;
-        break;
-      case "entity_deleted":
-        affectedDocuments = await this.findAffectedByDeletion(change.entityName);
-        summary = `Entity "${change.entityName}" was deleted`;
-        break;
-      case "entity_type_changed":
-        affectedDocuments = await this.findAffectedByTypeChange(change.entityName, change.oldValue || "", change.newValue || "");
-        summary = `Entity "${change.entityName}" type changed from "${change.oldValue}" to "${change.newValue}"`;
-        break;
-      case "relationship_changed":
-        affectedDocuments = await this.findAffectedByRelationshipChange(change.entityName);
-        summary = `Relationship involving "${change.entityName}" was changed`;
-        break;
-      case "document_deleted":
-        affectedDocuments = await this.findAffectedByDocumentDeletion(change.documentPath);
-        summary = `Document "${change.documentPath}" was deleted`;
-        break;
-      default:
-        summary = `Unknown change type for entity "${change.entityName}"`;
-    }
-    affectedDocuments = affectedDocuments.filter((doc) => doc.path !== change.documentPath);
-    return {
-      trigger: change.trigger,
-      sourceDocument: change.documentPath,
-      affectedDocuments,
-      summary
-    };
-  }
-  detectEntityRenames(oldDoc, newDoc) {
-    const changes = [];
-    const oldNames = new Set(oldDoc.entities.map((e) => e.name));
-    const newNames = new Set(newDoc.entities.map((e) => e.name));
-    const removedEntities = oldDoc.entities.filter((e) => !newNames.has(e.name));
-    const addedEntities = newDoc.entities.filter((e) => !oldNames.has(e.name));
-    const removedByType = new Map;
-    for (const entity of removedEntities) {
-      const existing = removedByType.get(entity.type) || [];
-      existing.push(entity);
-      removedByType.set(entity.type, existing);
-    }
-    const addedByType = new Map;
-    for (const entity of addedEntities) {
-      const existing = addedByType.get(entity.type) || [];
-      existing.push(entity);
-      addedByType.set(entity.type, existing);
-    }
-    for (const [type, removed] of removedByType) {
-      const added = addedByType.get(type) || [];
-      const pairCount = Math.min(removed.length, added.length);
-      for (let i = 0;i < pairCount; i++) {
-        changes.push({
-          trigger: "entity_renamed",
-          entityName: removed[i].name,
-          oldValue: removed[i].name,
-          newValue: added[i].name,
-          documentPath: oldDoc.path
-        });
-      }
-    }
-    return changes;
-  }
-  detectEntityDeletions(oldDoc, newDoc) {
-    const changes = [];
-    const newNames = new Set(newDoc.entities.map((e) => e.name));
-    const renames = this.detectEntityRenames(oldDoc, newDoc);
-    const renamedNames = new Set(renames.map((r) => r.oldValue));
-    for (const entity of oldDoc.entities) {
-      if (!newNames.has(entity.name) && !renamedNames.has(entity.name)) {
-        changes.push({
-          trigger: "entity_deleted",
-          entityName: entity.name,
-          documentPath: oldDoc.path
-        });
-      }
-    }
-    return changes;
-  }
-  detectEntityTypeChanges(oldDoc, newDoc) {
-    const changes = [];
-    const newEntityMap = new Map(newDoc.entities.map((e) => [e.name, e]));
-    for (const oldEntity of oldDoc.entities) {
-      const newEntity = newEntityMap.get(oldEntity.name);
-      if (newEntity && newEntity.type !== oldEntity.type) {
-        changes.push({
-          trigger: "entity_type_changed",
-          entityName: oldEntity.name,
-          oldValue: oldEntity.type,
-          newValue: newEntity.type,
-          documentPath: oldDoc.path
-        });
-      }
-    }
-    return changes;
-  }
-  async findAffectedByRename(entityName, _newName) {
-    try {
-      const escapedName = this.escapeForCypher(entityName);
-      const query = `
-				MATCH (e {name: '${escapedName}'})-[:APPEARS_IN]->(d:Document)
-				RETURN d.name, d.title
-			`.trim();
-      const result = await this.graph.query(query);
-      return (result.resultSet || []).map((row) => ({
-        path: row[0],
-        reason: `References "${entityName}" in entities`,
-        suggestedAction: "update_reference",
-        confidence: "high",
-        affectedEntities: [entityName]
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to find documents affected by rename: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async findAffectedByDeletion(entityName) {
-    try {
-      const escapedName = this.escapeForCypher(entityName);
-      const query = `
-				MATCH (e {name: '${escapedName}'})-[:APPEARS_IN]->(d:Document)
-				RETURN d.name, d.title
-			`.trim();
-      const result = await this.graph.query(query);
-      return (result.resultSet || []).map((row) => ({
-        path: row[0],
-        reason: `References deleted entity "${entityName}"`,
-        suggestedAction: "review_content",
-        confidence: "high",
-        affectedEntities: [entityName]
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to find documents affected by deletion: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async findAffectedByTypeChange(entityName, oldType, newType) {
-    try {
-      const escapedName = this.escapeForCypher(entityName);
-      const query = `
-				MATCH (e {name: '${escapedName}'})-[:APPEARS_IN]->(d:Document)
-				RETURN d.name, d.title
-			`.trim();
-      const result = await this.graph.query(query);
-      return (result.resultSet || []).map((row) => ({
-        path: row[0],
-        reason: `References "${entityName}" with type "${oldType}" (now "${newType}")`,
-        suggestedAction: "review_content",
-        confidence: "medium",
-        affectedEntities: [entityName]
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to find documents affected by type change: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async findAffectedByRelationshipChange(entityName) {
-    try {
-      const escapedName = this.escapeForCypher(entityName);
-      const query = `
-				MATCH (e {name: '${escapedName}'})-[r]->(d:Document)
-				RETURN d.name, d.title, type(r) as relType
-			`.trim();
-      const result = await this.graph.query(query);
-      return (result.resultSet || []).map((row) => ({
-        path: row[0],
-        reason: `Has relationship with "${entityName}"`,
-        suggestedAction: "review_content",
-        confidence: "medium",
-        affectedEntities: [entityName]
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to find documents affected by relationship change: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async findAffectedByDocumentDeletion(documentPath) {
-    try {
-      const escapedPath = this.escapeForCypher(documentPath);
-      const query = `
-				MATCH (d:Document)-[r]->(deleted:Document {name: '${escapedPath}'})
-				RETURN d.name, type(r) as relType
-			`.trim();
-      const result = await this.graph.query(query);
-      return (result.resultSet || []).map((row) => ({
-        path: row[0],
-        reason: `Links to deleted document "${documentPath}"`,
-        suggestedAction: "remove_reference",
-        confidence: "high",
-        affectedEntities: []
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to find documents affected by document deletion: ${error instanceof Error ? error.message : String(error)}`);
-      return [];
-    }
-  }
-  async analyzeDocumentChange(oldDoc, newDoc) {
-    if (!oldDoc) {
-      return [];
-    }
-    const analyses = [];
-    const renames = this.detectEntityRenames(oldDoc, newDoc);
-    const deletions = this.detectEntityDeletions(oldDoc, newDoc);
-    const typeChanges = this.detectEntityTypeChanges(oldDoc, newDoc);
-    for (const change of renames) {
-      const analysis = await this.analyzeEntityChange(change);
-      if (analysis.affectedDocuments.length > 0) {
-        analyses.push(analysis);
-      }
-    }
-    for (const change of deletions) {
-      const analysis = await this.analyzeEntityChange(change);
-      if (analysis.affectedDocuments.length > 0) {
-        analyses.push(analysis);
-      }
-    }
-    for (const change of typeChanges) {
-      const analysis = await this.analyzeEntityChange(change);
-      if (analysis.affectedDocuments.length > 0) {
-        analyses.push(analysis);
-      }
-    }
-    return analyses;
-  }
-  formatWarnings(analyses) {
-    if (analyses.length === 0) {
-      return "";
-    }
-    const lines = [];
-    lines.push(`
-=== Cascade Impact Detected ===
-`);
-    for (const analysis of analyses) {
-      lines.push(analysis.summary);
-      lines.push(`  Source: ${analysis.sourceDocument}`);
-      lines.push("");
-      if (analysis.affectedDocuments.length > 0) {
-        lines.push(`  Affected documents (${analysis.affectedDocuments.length}):`);
-        for (const doc of analysis.affectedDocuments) {
-          lines.push(`    [${doc.confidence}] ${doc.path}`);
-          lines.push(`      ${doc.reason}`);
-          lines.push(`      -> Suggested: ${this.formatSuggestedAction(doc.suggestedAction, analysis)}`);
-        }
-      }
-      lines.push("");
-    }
-    return lines.join(`
-`);
-  }
-  formatSuggestedAction(action, analysis) {
-    switch (action) {
-      case "update_reference":
-        if (analysis.trigger === "entity_renamed") {
-          const match = analysis.summary.match(/renamed to "([^"]+)"/);
-          const newName = match ? match[1] : "new name";
-          return `Update reference to "${newName}"`;
-        }
-        return "Update reference";
-      case "remove_reference":
-        return "Remove broken reference";
-      case "review_content":
-        return "Review content for consistency";
-      case "add_entity":
-        return "Consider adding entity definition";
-      default:
-        return action;
-    }
-  }
-  escapeForCypher(value) {
-    return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"");
-  }
-}
-CascadeService = __legacyDecorateClassTS([
-  Injectable4(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService,
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
-  ])
-], CascadeService);
-
-// src/sync/path-resolver.service.ts
-import { Injectable as Injectable5, Logger as Logger4 } from "@nestjs/common";
-import { resolve as resolve3, isAbsolute } from "path";
-import { existsSync as existsSync2 } from "fs";
-class PathResolverService {
-  parser;
-  logger = new Logger4(PathResolverService.name);
-  constructor(parser) {
-    this.parser = parser;
-  }
-  getDocsPath() {
-    return this.parser.getDocsPath();
-  }
-  resolveDocPath(userPath, options = {}) {
-    const { requireExists = true, requireInDocs = true } = options;
-    let resolvedPath;
-    if (isAbsolute(userPath)) {
-      resolvedPath = userPath;
-    } else {
-      const fromCwd = resolve3(process.cwd(), userPath);
-      const fromDocs = resolve3(this.getDocsPath(), userPath);
-      const docsPrefix = "docs/";
-      const strippedFromDocs = userPath.startsWith(docsPrefix) ? resolve3(this.getDocsPath(), userPath.slice(docsPrefix.length)) : null;
-      if (this.isUnderDocs(fromCwd) && existsSync2(fromCwd)) {
-        resolvedPath = fromCwd;
-      } else if (strippedFromDocs && existsSync2(strippedFromDocs)) {
-        resolvedPath = strippedFromDocs;
-      } else if (existsSync2(fromDocs)) {
-        resolvedPath = fromDocs;
-      } else if (this.isUnderDocs(fromCwd)) {
-        resolvedPath = fromCwd;
-      } else if (strippedFromDocs) {
-        resolvedPath = strippedFromDocs;
-      } else {
-        resolvedPath = fromDocs;
-      }
-    }
-    if (requireInDocs && !this.isUnderDocs(resolvedPath)) {
-      throw new Error(`Path "${userPath}" resolves to "${resolvedPath}" which is outside the docs directory (${this.getDocsPath()})`);
-    }
-    if (requireExists && !existsSync2(resolvedPath)) {
-      throw new Error(`Path "${userPath}" does not exist (resolved to: ${resolvedPath})`);
-    }
-    return resolvedPath;
-  }
-  resolveDocPaths(userPaths, options = {}) {
-    return userPaths.map((p) => this.resolveDocPath(p, options));
-  }
-  isUnderDocs(absolutePath) {
-    const docsPath = this.getDocsPath();
-    const normalizedPath = absolutePath.replace(/\/$/, "");
-    const normalizedDocs = docsPath.replace(/\/$/, "");
-    return normalizedPath.startsWith(normalizedDocs + "/") || normalizedPath === normalizedDocs;
-  }
-  getRelativePath(absolutePath) {
-    const docsPath = this.getDocsPath();
-    if (absolutePath.startsWith(docsPath)) {
-      return absolutePath.slice(docsPath.length + 1);
-    }
-    return absolutePath;
-  }
-}
-PathResolverService = __legacyDecorateClassTS([
-  Injectable5(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
-  ])
-], PathResolverService);
-
-// src/embedding/embedding.service.ts
-import { Injectable as Injectable6, Logger as Logger5 } from "@nestjs/common";
-import { ConfigService as ConfigService2 } from "@nestjs/config";
-
-// src/embedding/embedding.types.ts
-var DEFAULT_EMBEDDING_CONFIG = {
-  provider: "voyage",
-  model: "voyage-3.5-lite",
-  dimensions: 512
-};
-
-// src/embedding/providers/openai.provider.ts
-class OpenAIEmbeddingProvider {
-  name = "openai";
-  dimensions;
-  model;
-  apiKey;
-  baseUrl = "https://api.openai.com/v1";
-  constructor(config) {
-    const apiKey = config?.apiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.");
-    }
-    this.apiKey = apiKey;
-    this.model = config?.model || "text-embedding-3-small";
-    this.dimensions = config?.dimensions || 1536;
-  }
-  async generateEmbedding(text) {
-    const embeddings = await this.generateEmbeddings([text]);
-    return embeddings[0];
-  }
-  async generateEmbeddings(texts) {
-    if (!texts || texts.length === 0) {
-      return [];
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}/embeddings`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify({
-          model: this.model,
-          input: texts,
-          dimensions: this.dimensions
-        })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(`OpenAI API error: ${response.status} ${JSON.stringify(error)}`);
-      }
-      const data = await response.json();
-      const sortedData = data.data.sort((a, b) => a.index - b.index);
-      return sortedData.map((item) => item.embedding);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to generate embeddings: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-}
-
-// src/embedding/providers/voyage.provider.ts
-class VoyageEmbeddingProvider {
-  name = "voyage";
-  dimensions;
-  model;
-  apiKey;
-  inputType;
-  baseUrl = "https://api.voyageai.com/v1";
-  constructor(config) {
-    const apiKey = config?.apiKey || process.env.VOYAGE_API_KEY;
-    if (!apiKey) {
-      throw new Error("Voyage API key is required. Set VOYAGE_API_KEY environment variable or pass apiKey in config.");
-    }
-    this.apiKey = apiKey;
-    this.model = config?.model || "voyage-3.5-lite";
-    this.dimensions = config?.dimensions || 512;
-    this.inputType = config?.inputType || "document";
-  }
-  async generateEmbedding(text) {
-    const embeddings = await this.generateEmbeddings([text]);
-    return embeddings[0];
-  }
-  async generateEmbeddings(texts) {
-    if (!texts || texts.length === 0) {
-      return [];
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}/embeddings`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.apiKey}`
-        },
-        body: JSON.stringify({
-          model: this.model,
-          input: texts,
-          output_dimension: this.dimensions,
-          input_type: this.inputType
-        })
-      });
-      if (!response.ok) {
-        const error = await response.json().catch(() => ({}));
-        throw new Error(`Voyage API error: ${response.status} ${JSON.stringify(error)}`);
-      }
-      const data = await response.json();
-      const sortedData = data.data.sort((a, b) => a.index - b.index);
-      return sortedData.map((item) => item.embedding);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to generate embeddings: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-}
-
-// src/embedding/providers/mock.provider.ts
-class MockEmbeddingProvider {
-  name = "mock";
-  dimensions;
-  constructor(dimensions = 1536) {
-    this.dimensions = dimensions;
-  }
-  async generateEmbedding(text) {
-    return this.generateDeterministicEmbedding(text);
-  }
-  async generateEmbeddings(texts) {
-    return Promise.all(texts.map((text) => this.generateEmbedding(text)));
-  }
-  generateDeterministicEmbedding(text) {
-    const embedding = new Array(this.dimensions);
-    let hash = 0;
-    for (let i = 0;i < text.length; i++) {
-      hash = (hash << 5) - hash + text.charCodeAt(i);
-      hash = hash & hash;
-    }
-    for (let i = 0;i < this.dimensions; i++) {
-      const seed = hash * (i + 1) ^ i * 31;
-      embedding[i] = (seed % 2000 - 1000) / 1000;
-    }
-    const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-    return embedding.map((val) => val / magnitude);
-  }
-}
-
-// src/embedding/embedding.service.ts
-class EmbeddingService {
-  configService;
-  logger = new Logger5(EmbeddingService.name);
-  provider;
-  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}`);
-  }
-  loadConfig() {
-    const providerEnv = this.configService.get("EMBEDDING_PROVIDER");
-    const modelEnv = this.configService.get("EMBEDDING_MODEL");
-    const dimensionsEnv = this.configService.get("EMBEDDING_DIMENSIONS");
-    const provider = providerEnv ?? DEFAULT_EMBEDDING_CONFIG.provider;
-    let apiKey;
-    if (provider === "voyage") {
-      apiKey = this.configService.get("VOYAGE_API_KEY");
-    } else if (provider === "openai") {
-      apiKey = this.configService.get("OPENAI_API_KEY");
-    }
-    return {
-      provider,
-      apiKey,
-      model: modelEnv ?? DEFAULT_EMBEDDING_CONFIG.model,
-      dimensions: dimensionsEnv ? Number(dimensionsEnv) : DEFAULT_EMBEDDING_CONFIG.dimensions
-    };
-  }
-  createProvider() {
-    switch (this.config.provider) {
-      case "openai":
-        if (!this.config.apiKey) {
-          throw new Error("OPENAI_API_KEY environment variable is required for embeddings. " + "Set it in .env or use --no-embeddings to skip embedding generation.");
-        }
-        return new OpenAIEmbeddingProvider({
-          apiKey: this.config.apiKey,
-          model: this.config.model,
-          dimensions: this.config.dimensions
-        });
-      case "mock":
-        return new MockEmbeddingProvider(this.config.dimensions);
-      case "voyage":
-        if (!this.config.apiKey) {
-          throw new Error("VOYAGE_API_KEY environment variable is required for embeddings. " + "Set it in .env or use --no-embeddings to skip embedding generation.");
-        }
-        return new VoyageEmbeddingProvider({
-          apiKey: this.config.apiKey,
-          model: this.config.model,
-          dimensions: this.config.dimensions
-        });
-      case "nomic":
-        throw new Error(`Provider ${this.config.provider} not yet implemented. Use 'voyage', 'openai', or 'mock'.`);
-      default:
-        throw new Error(`Unknown embedding provider: ${this.config.provider}. Use 'voyage', 'openai', or 'mock'.`);
-    }
-  }
-  getProviderName() {
-    return this.provider.name;
-  }
-  getDimensions() {
-    return this.provider.dimensions;
-  }
-  async generateEmbedding(text) {
-    if (!text || text.trim().length === 0) {
-      throw new Error("Cannot generate embedding for empty text");
-    }
-    return this.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);
-  }
-  isRealProvider() {
-    return this.provider.name !== "mock";
-  }
-}
-EmbeddingService = __legacyDecorateClassTS([
-  Injectable6(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof ConfigService2 === "undefined" ? Object : ConfigService2
-  ])
-], EmbeddingService);
-
-// src/sync/sync.service.ts
-var ENTITY_TYPES = [
-  "Topic",
-  "Technology",
-  "Concept",
-  "Tool",
-  "Process",
-  "Person",
-  "Organization"
-];
-function validateDocuments(docs) {
-  const errors = [];
-  const entityIndex = new Map;
-  for (const doc of docs) {
-    for (const entity of doc.entities) {
-      if (!entityIndex.has(entity.name)) {
-        entityIndex.set(entity.name, new Set);
-      }
-      entityIndex.get(entity.name).add(doc.path);
-    }
-  }
-  for (const doc of docs) {
-    for (const rel of doc.relationships) {
-      if (rel.source !== doc.path && !entityIndex.has(rel.source)) {
-        errors.push({
-          path: doc.path,
-          error: `Relationship source "${rel.source}" not found in any document`
-        });
-      }
-      const isDocPath = rel.target.endsWith(".md");
-      const isKnownEntity = entityIndex.has(rel.target);
-      const isSelfReference = rel.target === doc.path;
-      if (!isDocPath && !isKnownEntity && !isSelfReference) {
-        errors.push({
-          path: doc.path,
-          error: `Relationship target "${rel.target}" not found as entity`
-        });
-      }
-    }
-  }
-  return errors;
-}
-
-class SyncService {
-  manifest;
-  parser;
-  graph;
-  cascade;
-  pathResolver;
-  embeddingService;
-  logger = new Logger6(SyncService.name);
-  constructor(manifest, parser, graph, cascade, pathResolver, embeddingService) {
-    this.manifest = manifest;
-    this.parser = parser;
-    this.graph = graph;
-    this.cascade = cascade;
-    this.pathResolver = pathResolver;
-    this.embeddingService = embeddingService;
-  }
-  async sync(options = {}) {
-    const startTime = Date.now();
-    const result = {
-      added: 0,
-      updated: 0,
-      deleted: 0,
-      unchanged: 0,
-      errors: [],
-      duration: 0,
-      changes: [],
-      cascadeWarnings: [],
-      embeddingsGenerated: 0,
-      entityEmbeddingsGenerated: 0
-    };
-    try {
-      await this.manifest.load();
-      if (options.force) {
-        if (options.paths && options.paths.length > 0) {
-          if (options.verbose) {
-            this.logger.log(`Force mode: marking ${options.paths.length} document(s) for re-sync`);
-          }
-          await this.clearManifestEntries(options.paths);
-        } else {
-          if (options.verbose) {
-            this.logger.log("Force mode: clearing manifest to force full re-sync");
-          }
-          await this.clearManifest();
-        }
-      }
-      const changes = await this.detectChanges(options.paths);
-      result.changes = changes;
-      const docsToSync = [];
-      const docsByPath = new Map;
-      for (const change of changes) {
-        if (change.changeType === "new" || change.changeType === "updated") {
-          try {
-            const doc = await this.parser.parseDocument(change.path);
-            docsToSync.push(doc);
-            docsByPath.set(change.path, doc);
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            result.errors.push({ path: change.path, error: errorMessage });
-            this.logger.warn(`Failed to parse ${change.path}: ${errorMessage}`);
-          }
-        }
-      }
-      const validationErrors = validateDocuments(docsToSync);
-      if (validationErrors.length > 0) {
-        for (const err of validationErrors) {
-          result.errors.push(err);
-          this.logger.error(`Validation error in ${err.path}: ${err.error}`);
-        }
-        this.logger.error(`Sync aborted: ${validationErrors.length} validation error(s) found. Fix the errors and try again.`);
-        result.duration = Date.now() - startTime;
-        return result;
-      }
-      const uniqueEntities = this.collectUniqueEntities(docsToSync);
-      if (options.verbose) {
-        this.logger.log(`Collected ${uniqueEntities.size} unique entities from ${docsToSync.length} documents`);
-      }
-      if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
-        try {
-          const dimensions = this.embeddingService.getDimensions();
-          await this.graph.createVectorIndex("Document", "embedding", dimensions);
-        } catch (error) {
-          this.logger.debug(`Vector index setup for Document: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        await this.createEntityVectorIndices();
-      }
-      if (!options.dryRun) {
-        result.entityEmbeddingsGenerated = await this.syncEntities(uniqueEntities, options);
-        if (options.verbose) {
-          this.logger.log(`Synced ${uniqueEntities.size} entities, generated ${result.entityEmbeddingsGenerated} embeddings`);
-        }
-      }
-      for (const change of changes) {
-        try {
-          const doc = docsByPath.get(change.path);
-          const cascadeWarnings = await this.processChange(change, options, doc);
-          result.cascadeWarnings.push(...cascadeWarnings);
-          switch (change.changeType) {
-            case "new":
-              result.added++;
-              break;
-            case "updated":
-              result.updated++;
-              break;
-            case "deleted":
-              result.deleted++;
-              break;
-            case "unchanged":
-              result.unchanged++;
-              break;
-          }
-          if (change.embeddingGenerated) {
-            result.embeddingsGenerated++;
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          result.errors.push({ path: change.path, error: errorMessage });
-          this.logger.warn(`Error processing ${change.path}: ${errorMessage}`);
-        }
-      }
-      if (!options.dryRun) {
-        await this.manifest.save();
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Sync failed: ${errorMessage}`);
-      result.errors.push({ path: "sync", error: errorMessage });
-    }
-    result.duration = Date.now() - startTime;
-    return result;
-  }
-  async detectChanges(paths) {
-    const changes = [];
-    let allDocPaths = await this.parser.discoverDocuments();
-    if (paths && paths.length > 0) {
-      const normalizedPaths = this.pathResolver.resolveDocPaths(paths, {
-        requireExists: true,
-        requireInDocs: true
-      });
-      const pathSet = new Set(normalizedPaths);
-      allDocPaths = allDocPaths.filter((p) => pathSet.has(p));
-    }
-    const trackedPaths = new Set(this.manifest.getTrackedPaths());
-    for (const docPath of allDocPaths) {
-      try {
-        const doc = await this.parser.parseDocument(docPath);
-        const changeType = this.manifest.detectChange(docPath, doc.contentHash, doc.frontmatterHash);
-        changes.push({
-          path: docPath,
-          changeType,
-          reason: this.getChangeReason(changeType)
-        });
-        trackedPaths.delete(docPath);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logger.warn(`Failed to parse ${docPath}: ${errorMessage}`);
-        changes.push({
-          path: docPath,
-          changeType: "new",
-          reason: `Parse error: ${errorMessage}`
-        });
-        trackedPaths.delete(docPath);
-      }
-    }
-    if (!paths || paths.length === 0) {
-      for (const deletedPath of trackedPaths) {
-        changes.push({
-          path: deletedPath,
-          changeType: "deleted",
-          reason: "File no longer exists"
-        });
-      }
-    }
-    return changes;
-  }
-  async syncDocument(doc, options = {}, skipEntityCreation = false) {
-    await this.graph.deleteDocumentRelationships(doc.path);
-    const documentProps = {
-      name: doc.path,
-      title: doc.title,
-      contentHash: doc.contentHash,
-      tags: doc.tags
-    };
-    if (doc.summary)
-      documentProps.summary = doc.summary;
-    if (doc.created)
-      documentProps.created = doc.created;
-    if (doc.updated)
-      documentProps.updated = doc.updated;
-    if (doc.status)
-      documentProps.status = doc.status;
-    if (doc.graphMetadata) {
-      if (doc.graphMetadata.importance) {
-        documentProps.importance = doc.graphMetadata.importance;
-      }
-      if (doc.graphMetadata.domain) {
-        documentProps.domain = doc.graphMetadata.domain;
-      }
-    }
-    await this.graph.upsertNode("Document", documentProps);
-    let embeddingGenerated = false;
-    if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
-      try {
-        const textForEmbedding = this.composeEmbeddingText(doc);
-        if (textForEmbedding.trim()) {
-          const embedding = await this.embeddingService.generateEmbedding(textForEmbedding);
-          await this.graph.updateNodeEmbedding("Document", doc.path, embedding);
-          embeddingGenerated = true;
-          this.logger.debug(`Generated embedding for ${doc.path}`);
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.logger.warn(`Failed to generate embedding for ${doc.path}: ${errorMessage}`);
-      }
-    }
-    const entityTypeMap = new Map;
-    entityTypeMap.set(doc.path, "Document");
-    this.logger.debug(`syncDocument: ${doc.path} has ${doc.entities.length} entities, skipEntityCreation=${skipEntityCreation}`);
-    for (const entity of doc.entities) {
-      entityTypeMap.set(entity.name, entity.type);
-      if (!skipEntityCreation) {
-        const entityProps = {
-          name: entity.name
-        };
-        if (entity.description) {
-          entityProps.description = entity.description;
-        }
-        await this.graph.upsertNode(entity.type, entityProps);
-      }
-      this.logger.debug(`Creating APPEARS_IN: ${entity.type}:${entity.name} -> Document:${doc.path}`);
-      await this.graph.upsertRelationship(entity.type, entity.name, "APPEARS_IN", "Document", doc.path, { documentPath: doc.path });
-    }
-    for (const rel of doc.relationships) {
-      if (rel.source === "this") {
-        const targetType2 = entityTypeMap.get(rel.target);
-        if (!targetType2) {
-          this.logger.warn(`Unknown target entity "${rel.target}" in relationship, document: ${doc.path}`);
-          continue;
-        }
-        await this.graph.upsertRelationship("Document", doc.path, rel.relation, targetType2, rel.target, { documentPath: doc.path });
-        continue;
-      }
-      if (rel.target.endsWith(".md")) {
-        const sourceType2 = entityTypeMap.get(rel.source);
-        if (!sourceType2) {
-          this.logger.warn(`Unknown source entity "${rel.source}" in relationship, document: ${doc.path}`);
-          continue;
-        }
-        await this.graph.upsertRelationship(sourceType2, rel.source, rel.relation, "Document", rel.target, { documentPath: doc.path });
-        continue;
-      }
-      const sourceType = entityTypeMap.get(rel.source);
-      const targetType = entityTypeMap.get(rel.target);
-      if (!sourceType) {
-        this.logger.warn(`Unknown source entity "${rel.source}" in relationship, document: ${doc.path}`);
-        continue;
-      }
-      if (!targetType) {
-        this.logger.warn(`Unknown target entity "${rel.target}" in relationship, document: ${doc.path}`);
-        continue;
-      }
-      await this.graph.upsertRelationship(sourceType, rel.source, rel.relation, targetType, rel.target, { documentPath: doc.path });
-    }
-    return embeddingGenerated;
-  }
-  async removeDocument(path) {
-    await this.graph.deleteDocumentRelationships(path);
-    await this.graph.deleteNode("Document", path);
-  }
-  async processChange(change, options, preloadedDoc) {
-    const cascadeWarnings = [];
-    if (options.verbose) {
-      this.logger.log(`Processing ${change.changeType}: ${change.path}`);
-    }
-    if (options.dryRun) {
-      this.logger.log(`[DRY-RUN] Would ${change.changeType}: ${change.path}`);
-      return cascadeWarnings;
-    }
-    switch (change.changeType) {
-      case "new":
-      case "updated": {
-        const doc = preloadedDoc || await this.parser.parseDocument(change.path);
-        if (change.changeType === "updated" && !options.skipCascade) {
-          try {
-            const oldDoc = await this.getOldDocumentFromManifest(change.path);
-            if (oldDoc) {
-              const cascadeAnalyses = await this.cascade.analyzeDocumentChange(oldDoc, doc);
-              if (cascadeAnalyses.length > 0) {
-                cascadeWarnings.push(...cascadeAnalyses);
-                cascadeAnalyses.forEach((cascade) => {
-                  this.logger.debug(`Cascade detected: ${cascade.trigger} in ${cascade.sourceDocument}`);
-                });
-              }
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.logger.warn(`Failed to analyze cascade impacts for ${change.path}: ${errorMessage}`);
-          }
-        }
-        const embeddingGenerated = await this.syncDocument(doc, options, preloadedDoc !== undefined);
-        change.embeddingGenerated = embeddingGenerated;
-        this.manifest.updateEntry(doc.path, doc.contentHash, doc.frontmatterHash, doc.entities.length, doc.relationships.length);
-        break;
-      }
-      case "deleted": {
-        await this.removeDocument(change.path);
-        this.manifest.removeEntry(change.path);
-        break;
-      }
-      case "unchanged":
-        break;
-    }
-    return cascadeWarnings;
-  }
-  async clearGraph() {
-    await this.graph.query("MATCH (n) DETACH DELETE n");
-    this.logger.log("Graph cleared");
-  }
-  async clearManifest() {
-    const manifest = await this.manifest.load();
-    for (const path of Object.keys(manifest.documents)) {
-      this.manifest.removeEntry(path);
-    }
-    this.logger.log("Manifest cleared");
-  }
-  async clearManifestEntries(paths) {
-    const normalizedPaths = this.pathResolver.resolveDocPaths(paths, {
-      requireExists: true,
-      requireInDocs: true
-    });
-    for (const docPath of normalizedPaths) {
-      this.manifest.removeEntry(docPath);
-      this.logger.debug(`Cleared manifest entry: ${docPath}`);
-    }
-    this.logger.log(`Marked ${normalizedPaths.length} document(s) for re-sync`);
-  }
-  composeEmbeddingText(doc) {
-    const parts = [];
-    if (doc.title) {
-      parts.push(`Title: ${doc.title}`);
-    }
-    if (doc.topic) {
-      parts.push(`Topic: ${doc.topic}`);
-    }
-    if (doc.tags && doc.tags.length > 0) {
-      parts.push(`Tags: ${doc.tags.join(", ")}`);
-    }
-    if (doc.entities && doc.entities.length > 0) {
-      const entityNames = doc.entities.map((e) => e.name).join(", ");
-      parts.push(`Entities: ${entityNames}`);
-    }
-    if (doc.summary) {
-      parts.push(doc.summary);
-    } else {
-      parts.push(doc.content.slice(0, 500));
-    }
-    return parts.join(" | ");
-  }
-  getChangeReason(changeType) {
-    switch (changeType) {
-      case "new":
-        return "New document";
-      case "updated":
-        return "Content or frontmatter changed";
-      case "deleted":
-        return "File no longer exists";
-      case "unchanged":
-        return "No changes detected";
-    }
-  }
-  async getOldDocumentFromManifest(path) {
-    try {
-      const manifest = await this.manifest.load();
-      const entry = manifest.documents[path];
-      if (!entry) {
-        return null;
-      }
-      try {
-        return await this.parser.parseDocument(path);
-      } catch {
-        return null;
-      }
-    } catch (error) {
-      this.logger.warn(`Failed to retrieve old document for ${path}: ${error instanceof Error ? error.message : String(error)}`);
-      return null;
-    }
-  }
-  collectUniqueEntities(docs) {
-    const entities = new Map;
-    for (const doc of docs) {
-      for (const entity of doc.entities) {
-        const key = `${entity.type}:${entity.name}`;
-        if (!entities.has(key)) {
-          entities.set(key, {
-            type: entity.type,
-            name: entity.name,
-            description: entity.description,
-            documentPaths: [doc.path]
-          });
-        } else {
-          const existing = entities.get(key);
-          existing.documentPaths.push(doc.path);
-          if (entity.description && (!existing.description || entity.description.length > existing.description.length)) {
-            existing.description = entity.description;
-          }
-        }
-      }
-    }
-    return entities;
-  }
-  async syncEntities(entities, options) {
-    let embeddingsGenerated = 0;
-    for (const [_key, entity] of entities) {
-      const entityProps = {
-        name: entity.name
-      };
-      if (entity.description) {
-        entityProps.description = entity.description;
-      }
-      await this.graph.upsertNode(entity.type, entityProps);
-      if (options.embeddings && !options.skipEmbeddings && this.embeddingService) {
-        try {
-          const text = this.composeEntityEmbeddingText(entity);
-          const embedding = await this.embeddingService.generateEmbedding(text);
-          await this.graph.updateNodeEmbedding(entity.type, entity.name, embedding);
-          embeddingsGenerated++;
-          this.logger.debug(`Generated embedding for ${entity.type}:${entity.name}`);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          this.logger.warn(`Failed to generate embedding for ${entity.type}:${entity.name}: ${errorMessage}`);
-        }
-      }
-    }
-    return embeddingsGenerated;
-  }
-  composeEntityEmbeddingText(entity) {
-    const parts = [`${entity.type}: ${entity.name}`];
-    if (entity.description) {
-      parts.push(entity.description);
-    }
-    return parts.join(". ");
-  }
-  async createEntityVectorIndices() {
-    if (!this.embeddingService)
-      return;
-    const dimensions = this.embeddingService.getDimensions();
-    for (const entityType of ENTITY_TYPES) {
-      try {
-        await this.graph.createVectorIndex(entityType, "embedding", dimensions);
-      } catch (error) {
-        this.logger.debug(`Vector index setup for ${entityType}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  }
-}
-SyncService = __legacyDecorateClassTS([
-  Injectable7(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof ManifestService === "undefined" ? Object : ManifestService,
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService,
-    typeof GraphService === "undefined" ? Object : GraphService,
-    typeof CascadeService === "undefined" ? Object : CascadeService,
-    typeof PathResolverService === "undefined" ? Object : PathResolverService,
-    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
-  ])
-], SyncService);
-
-// src/sync/ontology.service.ts
-import { Injectable as Injectable8 } from "@nestjs/common";
-class OntologyService {
-  parser;
-  constructor(parser) {
-    this.parser = parser;
-  }
-  async deriveOntology() {
-    const docs = await this.parser.parseAllDocuments();
-    return this.deriveFromDocuments(docs);
-  }
-  deriveFromDocuments(docs) {
-    const entityTypeSet = new Set;
-    const relationshipTypeSet = new Set;
-    const entityCounts = {};
-    const relationshipCounts = {};
-    const entityExamples = {};
-    let documentsWithEntities = 0;
-    let documentsWithoutEntities = 0;
-    let totalRelationships = 0;
-    for (const doc of docs) {
-      if (doc.entities.length > 0) {
-        documentsWithEntities++;
-      } else {
-        documentsWithoutEntities++;
-      }
-      for (const entity of doc.entities) {
-        entityTypeSet.add(entity.type);
-        entityCounts[entity.type] = (entityCounts[entity.type] || 0) + 1;
-        if (!entityExamples[entity.name]) {
-          entityExamples[entity.name] = { type: entity.type, documents: [] };
-        }
-        if (!entityExamples[entity.name].documents.includes(doc.path)) {
-          entityExamples[entity.name].documents.push(doc.path);
-        }
-      }
-      for (const rel of doc.relationships) {
-        relationshipTypeSet.add(rel.relation);
-        relationshipCounts[rel.relation] = (relationshipCounts[rel.relation] || 0) + 1;
-        totalRelationships++;
-      }
-    }
-    return {
-      entityTypes: Array.from(entityTypeSet).sort(),
-      relationshipTypes: Array.from(relationshipTypeSet).sort(),
-      entityCounts,
-      relationshipCounts,
-      totalEntities: Object.keys(entityExamples).length,
-      totalRelationships,
-      documentsWithEntities,
-      documentsWithoutEntities,
-      entityExamples
-    };
-  }
-  printSummary(ontology) {
-    console.log(`
-Derived Ontology Summary
-`);
-    console.log(`Documents: ${ontology.documentsWithEntities} with entities, ${ontology.documentsWithoutEntities} without`);
-    console.log(`Unique Entities: ${ontology.totalEntities}`);
-    console.log(`Total Relationships: ${ontology.totalRelationships}`);
-    console.log(`
-Entity Types:`);
-    for (const type of ontology.entityTypes) {
-      console.log(`  ${type}: ${ontology.entityCounts[type]} instances`);
-    }
-    console.log(`
-Relationship Types:`);
-    for (const type of ontology.relationshipTypes) {
-      console.log(`  ${type}: ${ontology.relationshipCounts[type]} instances`);
-    }
-    console.log(`
-Top Entities (by document count):`);
-    const sorted = Object.entries(ontology.entityExamples).sort((a, b) => b[1].documents.length - a[1].documents.length).slice(0, 10);
-    for (const [name, info] of sorted) {
-      console.log(`  ${name} (${info.type}): ${info.documents.length} docs`);
-    }
-  }
-}
-OntologyService = __legacyDecorateClassTS([
-  Injectable8(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
-  ])
-], OntologyService);
-
-// src/embedding/embedding.module.ts
-import { Module as Module2 } from "@nestjs/common";
-import { ConfigModule } from "@nestjs/config";
-class EmbeddingModule {
-}
-EmbeddingModule = __legacyDecorateClassTS([
-  Module2({
-    imports: [ConfigModule],
-    providers: [EmbeddingService],
-    exports: [EmbeddingService]
-  })
-], EmbeddingModule);
-
-// src/sync/sync.module.ts
-class SyncModule {
-}
-SyncModule = __legacyDecorateClassTS([
-  Module3({
-    imports: [GraphModule, EmbeddingModule],
-    providers: [
-      SyncService,
-      ManifestService,
-      DocumentParserService,
-      OntologyService,
-      CascadeService,
-      PathResolverService
-    ],
-    exports: [
-      SyncService,
-      ManifestService,
-      DocumentParserService,
-      OntologyService,
-      CascadeService,
-      PathResolverService
-    ]
-  })
-], SyncModule);
-
-// src/query/query.module.ts
-import { Module as Module4 } from "@nestjs/common";
-
-// src/query/query.service.ts
-import { Injectable as Injectable9, Logger as Logger7 } from "@nestjs/common";
-class QueryService {
-  graphService;
-  logger = new Logger7(QueryService.name);
-  constructor(graphService) {
-    this.graphService = graphService;
-  }
-  async query(cypher) {
-    this.logger.debug(`Executing query: ${cypher}`);
-    return await this.graphService.query(cypher);
-  }
-}
-QueryService = __legacyDecorateClassTS([
-  Injectable9(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
-  ])
-], QueryService);
-
-// src/query/query.module.ts
-class QueryModule {
-}
-QueryModule = __legacyDecorateClassTS([
-  Module4({
-    imports: [GraphModule, EmbeddingModule],
-    providers: [QueryService, GraphService],
-    exports: [QueryService, GraphService]
-  })
-], QueryModule);
-
-// src/commands/sync.command.ts
-import { Injectable as Injectable10 } from "@nestjs/common";
-import { Command, CommandRunner, Option } from "nest-commander";
-import { watch } from "fs";
-import { join } from "path";
-class SyncCommand extends CommandRunner {
-  syncService;
-  watcher = null;
-  isShuttingDown = false;
-  constructor(syncService) {
-    super();
-    this.syncService = syncService;
-  }
-  async run(paths, options) {
-    if (options.watch && options.dryRun) {
-      console.log(`
-\u26A0\uFE0F  Watch mode is not compatible with --dry-run mode
-`);
-      process.exit(1);
-    }
-    if (options.watch && options.force) {
-      console.log(`
-\u26A0\uFE0F  Watch mode is not compatible with --force mode (for safety)
-`);
-      process.exit(1);
-    }
-    const syncOptions = {
-      force: options.force,
-      dryRun: options.dryRun || options.diff,
-      verbose: options.verbose,
-      paths: paths.length > 0 ? paths : undefined,
-      skipCascade: options.skipCascade,
-      embeddings: options.embeddings !== false
-    };
-    console.log(`
-\uD83D\uDD04 Graph Sync
-`);
-    if (syncOptions.force) {
-      if (syncOptions.paths && syncOptions.paths.length > 0) {
-        console.log(`\u26A0\uFE0F  Force mode: ${syncOptions.paths.length} document(s) will be cleared and re-synced
-`);
-      } else {
-        console.log(`\u26A0\uFE0F  Force mode: Entire graph will be cleared and rebuilt
-`);
-      }
-    }
-    if (syncOptions.dryRun) {
-      console.log(`\uD83D\uDCCB Dry run mode: No changes will be applied
-`);
-    }
-    if (syncOptions.skipCascade) {
-      console.log(`\u26A1 Cascade analysis skipped
-`);
-    }
-    if (!syncOptions.embeddings) {
-      console.log(`\uD83D\uDEAB Embedding generation disabled
-`);
-    }
-    if (syncOptions.paths) {
-      console.log(`\uD83D\uDCC1 Syncing specific paths: ${syncOptions.paths.join(", ")}
-`);
-    }
-    try {
-      const initialResult = await this.syncService.sync(syncOptions);
-      this.printSyncResults(initialResult, options.watch);
-      if (options.dryRun) {
-        console.log("\uD83D\uDCA1 Run without --dry-run to apply changes");
-      }
-      if (options.watch) {
-        await this.enterWatchMode(syncOptions);
-      } else {
-        process.exit(initialResult.errors.length > 0 ? 1 : 0);
-      }
-    } catch (error) {
-      console.error(`
-\u274C Sync failed:`, error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  async enterWatchMode(syncOptions) {
-    const docsPath = process.env.DOCS_PATH || "docs";
-    let debounceTimeout = null;
-    const trackedFiles = new Set;
-    const debouncedSync = () => {
-      if (debounceTimeout) {
-        clearTimeout(debounceTimeout);
-      }
-      debounceTimeout = setTimeout(async () => {
-        if (this.isShuttingDown)
-          return;
-        if (trackedFiles.size === 0)
-          return;
-        try {
-          const changedPaths = Array.from(trackedFiles);
-          trackedFiles.clear();
-          console.log(`
-\uD83D\uDCDD Changes detected (${changedPaths.length} file${changedPaths.length !== 1 ? "s" : ""})`);
-          const watchResult = await this.syncService.sync({
-            ...syncOptions,
-            paths: changedPaths,
-            dryRun: false
-          });
-          const hasChanges = watchResult.added > 0 || watchResult.updated > 0 || watchResult.deleted > 0;
-          if (hasChanges) {
-            console.log(`   \u2705 Synced: +${watchResult.added} ~${watchResult.updated} -${watchResult.deleted}`);
-            if (watchResult.errors.length > 0) {
-              console.log(`   \u274C Errors: ${watchResult.errors.map((e) => e.path).join(", ")}`);
-            }
-            if (watchResult.cascadeWarnings && watchResult.cascadeWarnings.length > 0) {
-              console.log(`   \u26A0\uFE0F  Cascade impacts detected: ${watchResult.cascadeWarnings.length} warning(s)`);
-            }
-          } else {
-            console.log("   \u23ED\uFE0F  No changes detected");
-          }
-          console.log(`\u23F3 Watching for changes...
-`);
-        } catch (error) {
-          console.error(`   \u274C Sync failed: ${error instanceof Error ? error.message : String(error)}`);
-          console.log(`\u23F3 Watching for changes...
-`);
-        }
-      }, 500);
-    };
-    console.log(`
-\uD83D\uDC41\uFE0F  Watch mode enabled
-`);
-    this.watcher = watch(docsPath, { recursive: true }, (event, filename) => {
-      if (filename && filename.endsWith(".md")) {
-        const fullPath = join(docsPath, filename);
-        trackedFiles.add(fullPath);
-        debouncedSync();
-      }
-    });
-    process.on("SIGINT", () => this.shutdown());
-    await new Promise(() => {});
-  }
-  shutdown() {
-    if (this.isShuttingDown)
-      return;
-    this.isShuttingDown = true;
-    console.log(`
-
-\uD83D\uDC4B Stopping watch mode...`);
-    if (this.watcher) {
-      this.watcher.close();
-    }
-    process.exit(0);
-  }
-  printSyncResults(result, isWatchMode = false) {
-    console.log(`
-\uD83D\uDCCA Sync Results:
-`);
-    console.log(`  \u2705 Added: ${result.added}`);
-    console.log(`  \uD83D\uDD04 Updated: ${result.updated}`);
-    console.log(`  \uD83D\uDDD1\uFE0F  Deleted: ${result.deleted}`);
-    console.log(`  \u23ED\uFE0F  Unchanged: ${result.unchanged}`);
-    if (result.embeddingsGenerated > 0) {
-      console.log(`  \uD83E\uDDE0 Embeddings: ${result.embeddingsGenerated}`);
-    }
-    console.log(`  \u23F1\uFE0F  Duration: ${result.duration}ms`);
-    if (result.errors.length > 0) {
-      console.log(`
-\u274C Errors (${result.errors.length}):
-`);
-      result.errors.forEach((e) => {
-        console.log(`  ${e.path}: ${e.error}`);
-      });
-    }
-    if (result.changes && result.changes.length > 0) {
-      console.log(`
-\uD83D\uDCDD Changes:
-`);
-      result.changes.forEach((c) => {
-        const icon = {
-          new: "\u2795",
-          updated: "\uD83D\uDD04",
-          deleted: "\uD83D\uDDD1\uFE0F",
-          unchanged: "\u23ED\uFE0F"
-        }[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(`
-\u26A0\uFE0F  Cascade Impacts Detected:
-`);
-      const warningsByTrigger = new Map;
-      for (const warning of result.cascadeWarnings) {
-        const existing = warningsByTrigger.get(warning.trigger) || [];
-        existing.push(warning);
-        warningsByTrigger.set(warning.trigger, existing);
-      }
-      for (const [trigger, warnings] of warningsByTrigger) {
-        const triggerLabel = trigger.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-        console.log(`  \uD83D\uDCCC ${triggerLabel}
-`);
-        for (const analysis of warnings) {
-          console.log(`    ${analysis.summary}`);
-          console.log(`    Source: ${analysis.sourceDocument}
-`);
-          if (analysis.affectedDocuments.length > 0) {
-            for (const affected of analysis.affectedDocuments) {
-              const icon = affected.confidence === "high" ? "\uD83D\uDD34" : affected.confidence === "medium" ? "\uD83D\uDFE1" : "\uD83D\uDFE2";
-              console.log(`      ${icon} [${affected.confidence.toUpperCase()}] ${affected.path}`);
-              console.log(`         ${affected.reason}`);
-              const suggestedAction = affected.suggestedAction.split("_").join(" ").replace(/\b\w/g, (char) => char.toUpperCase());
-              console.log(`         \u2192 ${suggestedAction}`);
-            }
-          } else {
-            console.log(`      \u2139\uFE0F  No directly affected documents detected`);
-          }
-          console.log();
-        }
-      }
-      console.log(`  \uD83D\uDCA1 Run /update-related to apply suggested changes
-`);
-    }
-    if (isWatchMode) {
-      console.log(`
-\u23F3 Watching for changes... (Ctrl+C to stop)
-`);
-    }
-  }
-  parseForce() {
-    return true;
-  }
-  parseDryRun() {
-    return true;
-  }
-  parseVerbose() {
-    return true;
-  }
-  parseWatch() {
-    return true;
-  }
-  parseDiff() {
-    return true;
-  }
-  parseSkipCascade() {
-    return true;
-  }
-  parseNoEmbeddings() {
-    return false;
-  }
-}
-__legacyDecorateClassTS([
-  Option({
-    flags: "-f, --force",
-    description: "Force re-sync: with paths, clears only those docs; without paths, rebuilds entire graph"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseForce", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "-d, --dry-run",
-    description: "Show what would change without applying"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseDryRun", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "-v, --verbose",
-    description: "Show detailed output"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseVerbose", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "-w, --watch",
-    description: "Watch for file changes and sync automatically"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseWatch", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "--diff",
-    description: "Show only changed documents (alias for --dry-run)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseDiff", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "--skip-cascade",
-    description: "Skip cascade analysis (faster for large repos)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseSkipCascade", null);
-__legacyDecorateClassTS([
-  Option({
-    flags: "--no-embeddings",
-    description: "Disable embedding generation during sync"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], SyncCommand.prototype, "parseNoEmbeddings", null);
-SyncCommand = __legacyDecorateClassTS([
-  Injectable10(),
-  Command({
-    name: "sync",
-    arguments: "[paths...]",
-    description: "Synchronize documents to the knowledge graph"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof SyncService === "undefined" ? Object : SyncService
-  ])
-], SyncCommand);
-// src/commands/status.command.ts
-import { Injectable as Injectable11 } from "@nestjs/common";
-import { Command as Command2, CommandRunner as CommandRunner2, Option as Option2 } from "nest-commander";
-class StatusCommand extends CommandRunner2 {
-  syncService;
-  manifestService;
-  constructor(syncService, manifestService) {
-    super();
-    this.syncService = syncService;
-    this.manifestService = manifestService;
-  }
-  async run(_inputs, options) {
-    try {
-      await this.manifestService.load();
-      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");
-      const unchangedDocs = changes.filter((c) => c.changeType === "unchanged");
-      const pendingCount = newDocs.length + updatedDocs.length + deletedDocs.length;
-      console.log(`
-\uD83D\uDCCA Graph Status
-`);
-      if (newDocs.length > 0) {
-        console.log(`New (${newDocs.length}):`);
-        newDocs.forEach((doc) => {
-          console.log(`  + ${doc.path}`);
-        });
-        console.log();
-      }
-      if (updatedDocs.length > 0) {
-        console.log(`Updated (${updatedDocs.length}):`);
-        updatedDocs.forEach((doc) => {
-          console.log(`  ~ ${doc.path}`);
-        });
-        console.log();
-      }
-      if (deletedDocs.length > 0) {
-        console.log(`Deleted (${deletedDocs.length}):`);
-        deletedDocs.forEach((doc) => {
-          console.log(`  - ${doc.path}`);
-        });
-        console.log();
-      }
-      if (options.verbose && unchangedDocs.length > 0) {
-        console.log(`Unchanged (${unchangedDocs.length}):`);
-        unchangedDocs.forEach((doc) => {
-          console.log(`  \xB7 ${doc.path}`);
-        });
-        console.log();
-      }
-      if (pendingCount === 0) {
-        console.log(`\u2705 All documents are in sync
-`);
-      } else {
-        console.log(`Total: ${pendingCount} document(s) need syncing`);
-        console.log("\uD83D\uDCA1 Run `lattice sync` to apply changes\n");
-      }
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  parseVerbose() {
-    return true;
-  }
-}
-__legacyDecorateClassTS([
-  Option2({
-    flags: "-v, --verbose",
-    description: "Show all documents including unchanged"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], StatusCommand.prototype, "parseVerbose", null);
-StatusCommand = __legacyDecorateClassTS([
-  Injectable11(),
-  Command2({
-    name: "status",
-    description: "Show documents that need syncing (new or updated)"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof SyncService === "undefined" ? Object : SyncService,
-    typeof ManifestService === "undefined" ? Object : ManifestService
-  ])
-], StatusCommand);
-// src/commands/query.command.ts
-import { Injectable as Injectable12 } from "@nestjs/common";
-import { Command as Command3, CommandRunner as CommandRunner3, Option as Option3 } from "nest-commander";
-class StatsCommand extends CommandRunner3 {
-  graphService;
-  constructor(graphService) {
-    super();
-    this.graphService = graphService;
-  }
-  async run() {
-    try {
-      const stats = await this.graphService.getStats();
-      console.log(`
-=== Graph Statistics ===
-`);
-      console.log(`Total Nodes: ${stats.nodeCount}`);
-      console.log(`Total Relationships: ${stats.edgeCount}
-`);
-      console.log(`Node Labels (${stats.labels.length}):`);
-      stats.labels.forEach((label) => {
-        const count = stats.entityCounts[label] || 0;
-        console.log(`  - ${label}: ${count}`);
-      });
-      console.log(`
-Relationship Types (${stats.relationshipTypes.length}):`);
-      stats.relationshipTypes.forEach((relType) => {
-        const count = stats.relationshipCounts[relType] || 0;
-        console.log(`  - ${relType}: ${count}`);
-      });
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}
-StatsCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "stats",
-    description: "Show graph statistics"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
-  ])
-], StatsCommand);
-
-class SearchCommand extends CommandRunner3 {
-  graphService;
-  embeddingService;
-  constructor(graphService, embeddingService) {
-    super();
-    this.graphService = graphService;
-    this.embeddingService = embeddingService;
-  }
-  async run(inputs, options) {
-    const query = inputs[0];
-    const limit = Math.min(parseInt(options.limit || "20", 10), 100);
-    try {
-      const queryEmbedding = await this.embeddingService.generateEmbedding(query);
-      let results;
-      if (options.label) {
-        const labelResults = await this.graphService.vectorSearch(options.label, queryEmbedding, limit);
-        results = labelResults.map((r) => ({
-          name: r.name,
-          label: options.label,
-          title: r.title,
-          score: r.score
-        }));
-      } else {
-        results = await this.graphService.vectorSearchAll(queryEmbedding, limit);
-      }
-      const labelSuffix = options.label ? ` (${options.label})` : "";
-      console.log(`
-=== Semantic Search Results for "${query}"${labelSuffix} ===
-`);
-      if (results.length === 0) {
-        console.log(`No results found.
-`);
-        if (options.label) {
-          console.log(`Tip: Try without --label to search all entity types.
-`);
-        }
-        process.exit(0);
-      }
-      results.forEach((result, idx) => {
-        console.log(`${idx + 1}. [${result.label}] ${result.name}`);
-        if (result.title) {
-          console.log(`   Title: ${result.title}`);
-        }
-        if (result.description && result.label !== "Document") {
-          const desc = result.description.length > 80 ? result.description.slice(0, 80) + "..." : result.description;
-          console.log(`   ${desc}`);
-        }
-        console.log(`   Similarity: ${(result.score * 100).toFixed(2)}%`);
-      });
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      console.error("Error:", errorMsg);
-      if (errorMsg.includes("no embeddings") || errorMsg.includes("vector")) {
-        console.log(`
-Note: Semantic search requires embeddings to be generated first.`);
-        console.log(`Run 'lattice sync' to generate embeddings for documents.
-`);
-      }
-      process.exit(1);
-    }
-  }
-  parseLabel(value) {
-    return value;
-  }
-  parseLimit(value) {
-    return value;
-  }
-}
-__legacyDecorateClassTS([
-  Option3({
-    flags: "-l, --label <label>",
-    description: "Filter by entity label (e.g., Technology, Concept, Document)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", [
-    String
-  ]),
-  __legacyMetadataTS("design:returntype", String)
-], SearchCommand.prototype, "parseLabel", null);
-__legacyDecorateClassTS([
-  Option3({
-    flags: "--limit <n>",
-    description: "Limit results",
-    defaultValue: "20"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", [
-    String
-  ]),
-  __legacyMetadataTS("design:returntype", String)
-], SearchCommand.prototype, "parseLimit", null);
-SearchCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "search",
-    arguments: "<query>",
-    description: "Semantic search across the knowledge graph"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService,
-    typeof EmbeddingService === "undefined" ? Object : EmbeddingService
-  ])
-], SearchCommand);
-
-class RelsCommand extends CommandRunner3 {
-  graphService;
-  constructor(graphService) {
-    super();
-    this.graphService = graphService;
-  }
-  async run(inputs) {
-    const name = inputs[0];
-    try {
-      const escapedName = name.replace(/'/g, "\\'");
-      const cypher = `MATCH (a { name: '${escapedName}' })-[r]-(b) RETURN a, r, b`;
-      const result = await this.graphService.query(cypher);
-      const results = result.resultSet || [];
-      console.log(`
-=== Relationships for "${name}" ===
-`);
-      if (results.length === 0) {
-        console.log(`No relationships found.
-`);
-        process.exit(0);
-      }
-      const incoming = [];
-      const outgoing = [];
-      results.forEach((row) => {
-        const [source, rel, target] = row;
-        const sourceObj = Object.fromEntries(source);
-        const targetObj = Object.fromEntries(target);
-        const relObj = Object.fromEntries(rel);
-        const sourceProps = Object.fromEntries(sourceObj.properties || []);
-        const targetProps = Object.fromEntries(targetObj.properties || []);
-        const sourceName = sourceProps.name || "unknown";
-        const targetName = targetProps.name || "unknown";
-        const relType = relObj.type || "UNKNOWN";
-        if (sourceName === name) {
-          outgoing.push(`  -[${relType}]-> ${targetName}`);
-        } else {
-          incoming.push(`  <-[${relType}]- ${sourceName}`);
-        }
-      });
-      if (outgoing.length > 0) {
-        console.log("Outgoing:");
-        outgoing.forEach((r) => console.log(r));
-      }
-      if (incoming.length > 0) {
-        if (outgoing.length > 0)
-          console.log();
-        console.log("Incoming:");
-        incoming.forEach((r) => console.log(r));
-      }
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}
-RelsCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "rels",
-    arguments: "<name>",
-    description: "Show relationships for a node"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
-  ])
-], RelsCommand);
-
-class CypherCommand extends CommandRunner3 {
-  graphService;
-  constructor(graphService) {
-    super();
-    this.graphService = graphService;
-  }
-  async run(inputs) {
-    const query = inputs[0];
-    try {
-      const result = await this.graphService.query(query);
-      console.log(`
-=== Cypher Query Results ===
-`);
-      console.log(JSON.stringify(result, null, 2));
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}
-CypherCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "cypher",
-    arguments: "<query>",
-    description: "Execute raw Cypher query"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService
-  ])
-], CypherCommand);
-
-class RelatedCommand extends CommandRunner3 {
-  graphService;
-  pathResolverService;
-  constructor(graphService, pathResolverService) {
-    super();
-    this.graphService = graphService;
-    this.pathResolverService = pathResolverService;
-  }
-  async run(inputs, options) {
-    const path = inputs[0];
-    const limit = Math.min(parseInt(options.limit || "10", 10), 50);
-    try {
-      const absolutePath = this.pathResolverService.resolveDocPath(path, {
-        requireExists: true,
-        requireInDocs: true
-      });
-      const escapedPath = absolutePath.replace(/'/g, "\\'");
-      const cypher = `
-				MATCH (d:Document { name: '${escapedPath}' })<-[:APPEARS_IN]-(e)-[:APPEARS_IN]->(other:Document)
-				WHERE other.name <> '${escapedPath}'
-				RETURN DISTINCT other.name as path, other.title as title, count(e) as shared
-				ORDER BY shared DESC
-				LIMIT ${limit}
-			`;
-      const result = await this.graphService.query(cypher);
-      const results = result.resultSet || [];
-      console.log(`
-=== Documents Related to "${path}" ===
-`);
-      if (results.length === 0) {
-        console.log(`No related documents found.
-`);
-        process.exit(0);
-      }
-      results.forEach((row) => {
-        const docPath = row[0];
-        const title = row[1];
-        const shared = row[2];
-        console.log(`[${shared} shared entities] ${docPath}`);
-        if (title) {
-          console.log(`  Title: ${title}`);
-        }
-      });
-      console.log();
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  parseLimit(value) {
-    return value;
-  }
-}
-__legacyDecorateClassTS([
-  Option3({
-    flags: "--limit <n>",
-    description: "Limit results",
-    defaultValue: "10"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", [
-    String
-  ]),
-  __legacyMetadataTS("design:returntype", String)
-], RelatedCommand.prototype, "parseLimit", null);
-RelatedCommand = __legacyDecorateClassTS([
-  Injectable12(),
-  Command3({
-    name: "related",
-    arguments: "<path>",
-    description: "Find documents related to the given document"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof GraphService === "undefined" ? Object : GraphService,
-    typeof PathResolverService === "undefined" ? Object : PathResolverService
-  ])
-], RelatedCommand);
-// src/commands/validate.command.ts
-import { Injectable as Injectable13 } from "@nestjs/common";
-import { Command as Command4, CommandRunner as CommandRunner4, Option as Option4 } from "nest-commander";
-class ValidateCommand extends CommandRunner4 {
-  parserService;
-  constructor(parserService) {
-    super();
-    this.parserService = parserService;
-  }
-  async run(_inputs, options) {
-    try {
-      console.log(`Validating entities and relationships...
-`);
-      const { docs, errors: schemaErrors } = await this.parserService.parseAllDocumentsWithErrors();
-      const issues = [];
-      for (const schemaError of schemaErrors) {
-        issues.push({
-          type: "error",
-          path: schemaError.path,
-          message: schemaError.error
-        });
-      }
-      const entityIndex = new Map;
-      for (const doc of docs) {
-        for (const entity of doc.entities) {
-          if (!entityIndex.has(entity.name)) {
-            entityIndex.set(entity.name, new Set);
-          }
-          entityIndex.get(entity.name).add(doc.path);
-        }
-      }
-      const validationErrors = validateDocuments(docs);
-      for (const err of validationErrors) {
-        issues.push({
-          type: "error",
-          path: err.path,
-          message: err.error,
-          suggestion: "Add entity definition or fix the reference"
-        });
-      }
-      console.log(`Scanned ${docs.length} documents`);
-      console.log(`Found ${entityIndex.size} unique entities
-`);
-      if (issues.length > 0) {
-        console.log(`Errors (${issues.length}):
-`);
-        issues.forEach((i) => {
-          console.log(`  ${i.path}`);
-          console.log(`    Error: ${i.message}`);
-          if (options.fix && i.suggestion) {
-            console.log(`    Suggestion: ${i.suggestion}`);
-          }
-          console.log("");
-        });
-      }
-      if (issues.length === 0) {
-        console.log("All validations passed!");
-      }
-      process.exit(issues.length > 0 ? 1 : 0);
-    } catch (error) {
-      console.error("Validation failed:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  parseFix() {
-    return true;
-  }
-}
-__legacyDecorateClassTS([
-  Option4({
-    flags: "--fix",
-    description: "Show suggestions for common issues"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], ValidateCommand.prototype, "parseFix", null);
-ValidateCommand = __legacyDecorateClassTS([
-  Injectable13(),
-  Command4({
-    name: "validate",
-    description: "Validate entity references and relationships across documents"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof DocumentParserService === "undefined" ? Object : DocumentParserService
-  ])
-], ValidateCommand);
-// src/commands/ontology.command.ts
-import { Injectable as Injectable14 } from "@nestjs/common";
-import { Command as Command5, CommandRunner as CommandRunner5 } from "nest-commander";
-class OntologyCommand extends CommandRunner5 {
-  ontologyService;
-  constructor(ontologyService) {
-    super();
-    this.ontologyService = ontologyService;
-  }
-  async run() {
-    try {
-      const ontology = await this.ontologyService.deriveOntology();
-      this.ontologyService.printSummary(ontology);
-      process.exit(0);
-    } catch (error) {
-      console.error(`
-\u274C Ontology derivation failed:`, error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-}
-OntologyCommand = __legacyDecorateClassTS([
-  Injectable14(),
-  Command5({
-    name: "ontology",
-    description: "Derive and display ontology from all documents"
-  }),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof OntologyService === "undefined" ? Object : OntologyService
-  ])
-], OntologyCommand);
-// src/commands/init.command.ts
-import { Injectable as Injectable15 } from "@nestjs/common";
-import { Command as Command6, CommandRunner as CommandRunner6, Option as Option5 } from "nest-commander";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { homedir } from "os";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-var COMMANDS = ["research.md", "graph-sync.md", "entity-extract.md"];
-
-class InitCommand extends CommandRunner6 {
-  async run(_inputs, options) {
-    try {
-      const targetDir = options.global ? path.join(homedir(), ".claude", "commands") : path.join(process.cwd(), ".claude", "commands");
-      let commandsSourceDir = path.resolve(__dirname2, "..", "commands");
-      try {
-        await fs.access(commandsSourceDir);
-      } catch {
-        commandsSourceDir = path.resolve(__dirname2, "..", "..", "commands");
-      }
-      try {
-        await fs.access(commandsSourceDir);
-      } catch {
-        console.error("Error: Commands source directory not found at", commandsSourceDir);
-        console.error("This may indicate a corrupted installation. Try reinstalling @zabaca/lattice.");
-        process.exit(1);
-      }
-      await fs.mkdir(targetDir, { recursive: true });
-      let copied = 0;
-      let skipped = 0;
-      const installed = [];
-      for (const file of COMMANDS) {
-        const sourcePath = path.join(commandsSourceDir, file);
-        const targetPath = path.join(targetDir, file);
-        try {
-          await fs.access(sourcePath);
-          try {
-            await fs.access(targetPath);
-            const sourceContent = await fs.readFile(sourcePath, "utf-8");
-            const targetContent = await fs.readFile(targetPath, "utf-8");
-            if (sourceContent === targetContent) {
-              skipped++;
-              continue;
-            }
-          } catch {}
-          await fs.copyFile(sourcePath, targetPath);
-          installed.push(file);
-          copied++;
-        } catch (err) {
-          console.error(`Warning: Could not copy ${file}:`, err instanceof Error ? err.message : String(err));
-        }
-      }
-      console.log();
-      console.log(`\u2705 Lattice commands installed to ${targetDir}`);
-      console.log();
-      if (copied > 0) {
-        console.log(`Installed ${copied} command(s):`);
-        installed.forEach((f) => {
-          const name = f.replace(".md", "");
-          console.log(`  - /${name}`);
-        });
-      }
-      if (skipped > 0) {
-        console.log(`Skipped ${skipped} unchanged command(s)`);
-      }
-      console.log();
-      console.log("Available commands in Claude Code:");
-      console.log("  /research <topic>    - AI-assisted research workflow");
-      console.log("  /graph-sync          - Extract entities and sync to graph");
-      console.log("  /entity-extract      - Extract entities from a single document");
-      console.log();
-      if (!options.global) {
-        console.log("\uD83D\uDCA1 Tip: Use 'lattice init --global' to install for all projects");
-      }
-      process.exit(0);
-    } catch (error) {
-      console.error("Error:", error instanceof Error ? error.message : String(error));
-      process.exit(1);
-    }
-  }
-  parseGlobal() {
-    return true;
-  }
-}
-__legacyDecorateClassTS([
-  Option5({
-    flags: "-g, --global",
-    description: "Install to ~/.claude/commands/ (available in all projects)"
-  }),
-  __legacyMetadataTS("design:type", Function),
-  __legacyMetadataTS("design:paramtypes", []),
-  __legacyMetadataTS("design:returntype", Boolean)
-], InitCommand.prototype, "parseGlobal", null);
-InitCommand = __legacyDecorateClassTS([
-  Injectable15(),
-  Command6({
-    name: "init",
-    description: "Install Claude Code slash commands for Lattice"
-  })
-], InitCommand);
-// src/app.module.ts
-class AppModule {
-}
-AppModule = __legacyDecorateClassTS([
-  Module5({
-    imports: [
-      ConfigModule2.forRoot({
-        isGlobal: true
-      }),
-      GraphModule,
-      SyncModule,
-      EmbeddingModule,
-      QueryModule
-    ],
-    providers: [
-      SyncCommand,
-      StatusCommand,
-      StatsCommand,
-      SearchCommand,
-      RelsCommand,
-      CypherCommand,
-      RelatedCommand,
-      ValidateCommand,
-      OntologyCommand,
-      InitCommand
-    ]
-  })
-], AppModule);
-
-// src/main.ts
-async function bootstrap() {
-  await CommandFactory.run(AppModule, ["error"]);
-}
-bootstrap().catch((err) => {
-  console.error("\u274C CLI failed:", err);
-  process.exit(1);
-});