@zabaca/lattice 0.1.0

package/dist/cli.js

@@ -0,0 +1,2712 @@
+#!/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 { program } from "commander";
+
+// src/commands/sync.command.ts
+import { NestFactory } from "@nestjs/core";
+import { watch } from "fs";
+import { join } from "path";
+
+// 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 exists")) {
+        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 < 2) {
+      return;
+    }
+    const statsStr = result[1];
+    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 packages/graph/.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 packages/graph/.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/app.module.ts
+class AppModule {
+}
+AppModule = __legacyDecorateClassTS([
+  Module5({
+    imports: [
+      ConfigModule2.forRoot({
+        isGlobal: true
+      }),
+      GraphModule,
+      SyncModule,
+      EmbeddingModule,
+      QueryModule
+    ]
+  })
+], AppModule);
+
+// src/commands/sync.command.ts
+function registerSyncCommand(program) {
+  program.command("sync [paths...]").description("Synchronize documents to the knowledge graph").option("-f, --force", "Force re-sync: with paths, clears only those docs; without paths, rebuilds entire graph").option("-d, --dry-run", "Show what would change without applying").option("-v, --verbose", "Show detailed output").option("-w, --watch", "Watch for file changes and sync automatically").option("--diff", "Show only changed documents (alias for --dry-run)").option("--skip-cascade", "Skip cascade analysis (faster for large repos)").option("--no-embeddings", "Disable embedding generation during sync").action(async (paths, options) => {
+    let app;
+    let watcher = null;
+    let isShuttingDown = false;
+    const 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 (options.verbose && 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)
+`);
+      }
+    };
+    const shutdown = async () => {
+      if (isShuttingDown)
+        return;
+      isShuttingDown = true;
+      console.log(`
+
+\uD83D\uDC4B Stopping watch mode...`);
+      if (watcher) {
+        watcher.close();
+      }
+      if (app) {
+        await app.close();
+      }
+      process.exit(0);
+    };
+    try {
+      app = await NestFactory.createApplicationContext(AppModule, {
+        logger: options.verbose ? ["log", "error", "warn"] : false
+      });
+      const sync = app.get(SyncService);
+      if (options.watch && options.dryRun) {
+        console.log(`
+\u26A0\uFE0F  Watch mode is not compatible with --dry-run mode
+`);
+        await app.close();
+        process.exit(1);
+      }
+      if (options.watch && options.force) {
+        console.log(`
+\u26A0\uFE0F  Watch mode is not compatible with --force mode (for safety)
+`);
+        await app.close();
+        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(", ")}
+`);
+      }
+      const initialResult = await sync.sync(syncOptions);
+      printSyncResults(initialResult, options.watch);
+      if (options.dryRun) {
+        console.log("\uD83D\uDCA1 Run without --dry-run to apply changes");
+      }
+      if (options.watch) {
+        const docsPath = process.env.DOCS_PATH || "docs";
+        let debounceTimeout = null;
+        const trackedFiles = new Set;
+        const debouncedSync = () => {
+          if (debounceTimeout) {
+            clearTimeout(debounceTimeout);
+          }
+          debounceTimeout = setTimeout(async () => {
+            if (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 sync.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
+`);
+        watcher = watch(docsPath, { recursive: true }, (event, filename) => {
+          if (filename && filename.endsWith(".md")) {
+            const fullPath = join(docsPath, filename);
+            trackedFiles.add(fullPath);
+            debouncedSync();
+          }
+        });
+        process.on("SIGINT", shutdown);
+        await new Promise(() => {});
+      } else {
+        await app.close();
+        process.exit(initialResult.errors.length > 0 ? 1 : 0);
+      }
+    } catch (error) {
+      console.error(`
+\u274C Sync failed:`, error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+}
+// src/commands/status.command.ts
+import { NestFactory as NestFactory2 } from "@nestjs/core";
+function registerStatusCommand(program) {
+  program.command("status").description("Show documents that need syncing (new or updated)").option("-v, --verbose", "Show all documents including unchanged").action(async (options) => {
+    let app;
+    try {
+      app = await NestFactory2.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const sync = app.get(SyncService);
+      const manifest = app.get(ManifestService);
+      await manifest.load();
+      const changes = await sync.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 `bun graph sync` to apply changes\n");
+      }
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+}
+// src/commands/query.command.ts
+import { NestFactory as NestFactory3 } from "@nestjs/core";
+function registerQueryCommands(program) {
+  program.command("stats").description("Show graph statistics").action(async () => {
+    let app;
+    try {
+      app = await NestFactory3.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const graph = app.get(GraphService);
+      const stats = await graph.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();
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+  program.command("search").description("Search for nodes in the graph or perform semantic search").option("-l, --label <label>", "Filter by node label").option("-n, --name <name>", "Filter by name (substring match)").option("-s, --semantic <query>", "Perform semantic/vector search on documents").option("--limit <n>", "Limit results", "20").action(async (options) => {
+    let app;
+    try {
+      app = await NestFactory3.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const graph = app.get(GraphService);
+      if (options.semantic) {
+        const embedding = app.get(EmbeddingService);
+        const limit2 = Math.min(parseInt(options.limit, 10), 100);
+        try {
+          const queryEmbedding = await embedding.generateEmbedding(options.semantic);
+          const results2 = await graph.vectorSearchAll(queryEmbedding, limit2);
+          console.log(`
+=== Semantic Search Results for "${options.semantic}" ===
+`);
+          if (results2.length === 0) {
+            console.log(`No results found with semantic search.
+`);
+            await app.close();
+            process.exit(0);
+          }
+          results2.forEach((result2, idx) => {
+            console.log(`${idx + 1}. [${result2.label}] ${result2.name}`);
+            if (result2.title) {
+              console.log(`   Title: ${result2.title}`);
+            }
+            if (result2.description && result2.label !== "Document") {
+              const desc = result2.description.length > 80 ? result2.description.slice(0, 80) + "..." : result2.description;
+              console.log(`   ${desc}`);
+            }
+            console.log(`   Similarity: ${(result2.score * 100).toFixed(2)}%`);
+          });
+          console.log();
+          await app.close();
+          process.exit(0);
+        } catch (semanticError) {
+          const errorMsg = semanticError instanceof Error ? semanticError.message : String(semanticError);
+          console.error("Semantic search error:", errorMsg);
+          if (errorMsg.includes("no embeddings") || errorMsg.includes("vector")) {
+            console.log(`
+Note: Semantic search requires embeddings to be generated first.`);
+            console.log(`Run 'bun graph sync' to generate embeddings for documents.
+`);
+          }
+          await app.close();
+          process.exit(1);
+        }
+      }
+      let cypher;
+      const limit = Math.min(parseInt(options.limit, 10), 100);
+      if (options.label && options.name) {
+        const escapedLabel = options.label.replace(/`/g, "\\`");
+        const escapedName = options.name.replace(/'/g, "\\'");
+        cypher = `MATCH (n:\`${escapedLabel}\`) WHERE n.name CONTAINS '${escapedName}' RETURN n LIMIT ${limit}`;
+      } else if (options.label) {
+        const escapedLabel = options.label.replace(/`/g, "\\`");
+        cypher = `MATCH (n:\`${escapedLabel}\`) RETURN n LIMIT ${limit}`;
+      } else if (options.name) {
+        const escapedName = options.name.replace(/'/g, "\\'");
+        cypher = `MATCH (n) WHERE n.name CONTAINS '${escapedName}' RETURN n LIMIT ${limit}`;
+      } else {
+        cypher = `MATCH (n) RETURN n LIMIT ${limit}`;
+      }
+      const result = await graph.query(cypher);
+      const results = result.resultSet || [];
+      console.log(`
+=== Search Results (${results.length} nodes) ===
+`);
+      if (results.length === 0) {
+        console.log(`No nodes found matching criteria.
+`);
+        await app.close();
+        process.exit(0);
+      }
+      results.forEach((row) => {
+        const node = row[0];
+        const labels = (node.labels || []).join(", ");
+        const name = node.properties?.name || "unnamed";
+        console.log(`[${labels}] ${name}`);
+        if (node.properties?.description) {
+          console.log(`  Description: ${node.properties.description}`);
+        }
+        if (node.properties?.importance) {
+          console.log(`  Importance: ${node.properties.importance}`);
+        }
+      });
+      console.log();
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+  program.command("rels <name>").description("Show relationships for a node").action(async (name) => {
+    let app;
+    try {
+      app = await NestFactory3.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const graph = app.get(GraphService);
+      const escapedName = name.replace(/'/g, "\\'");
+      const cypher = `MATCH (a { name: '${escapedName}' })-[r]-(b) RETURN a, r, b`;
+      const result = await graph.query(cypher);
+      const results = result.resultSet || [];
+      console.log(`
+=== Relationships for "${name}" ===
+`);
+      if (results.length === 0) {
+        console.log(`No relationships found.
+`);
+        await app.close();
+        process.exit(0);
+      }
+      const incoming = [];
+      const outgoing = [];
+      results.forEach((row) => {
+        const [source, rel, target] = row;
+        const sourceName = source.properties?.name || "unknown";
+        const targetName = target.properties?.name || "unknown";
+        const relType = rel.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();
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+  program.command("cypher <query>").description("Execute raw Cypher query").action(async (query) => {
+    let app;
+    try {
+      app = await NestFactory3.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const graph = app.get(GraphService);
+      const result = await graph.query(query);
+      console.log(`
+=== Cypher Query Results ===
+`);
+      console.log(JSON.stringify(result, null, 2));
+      console.log();
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+  program.command("related <path>").description("Find documents related to the given document").option("--limit <n>", "Limit results", "10").action(async (path, options) => {
+    let app;
+    try {
+      app = await NestFactory3.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const graph = app.get(GraphService);
+      const pathResolver = app.get(PathResolverService);
+      const absolutePath = pathResolver.resolveDocPath(path, {
+        requireExists: true,
+        requireInDocs: true
+      });
+      const limit = Math.min(parseInt(options.limit, 10), 50);
+      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 graph.query(cypher);
+      const results = result.resultSet || [];
+      console.log(`
+=== Documents Related to "${path}" ===
+`);
+      if (results.length === 0) {
+        console.log(`No related documents found.
+`);
+        await app.close();
+        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();
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+}
+// src/commands/validate.command.ts
+import { NestFactory as NestFactory4 } from "@nestjs/core";
+function registerValidateCommand(program) {
+  program.command("validate").description("Validate entity references and relationships across documents").option("--fix", "Show suggestions for common issues").action(async (options) => {
+    let app;
+    try {
+      app = await NestFactory4.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const parser = app.get(DocumentParserService);
+      console.log(`Validating entities and relationships...
+`);
+      const { docs, errors: schemaErrors } = await parser.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!");
+      }
+      await app.close();
+      process.exit(issues.length > 0 ? 1 : 0);
+    } catch (error) {
+      console.error("Validation failed:", error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+}
+// src/commands/ontology.command.ts
+import { NestFactory as NestFactory5 } from "@nestjs/core";
+function registerOntologyCommand(program) {
+  program.command("ontology").description("Derive and display ontology from all documents").action(async () => {
+    let app;
+    try {
+      app = await NestFactory5.createApplicationContext(AppModule, {
+        logger: false
+      });
+      const ontologyService = app.get(OntologyService);
+      const ontology = await ontologyService.deriveOntology();
+      ontologyService.printSummary(ontology);
+      await app.close();
+      process.exit(0);
+    } catch (error) {
+      console.error(`
+\u274C Ontology derivation failed:`, error instanceof Error ? error.message : String(error));
+      if (app)
+        await app.close();
+      process.exit(1);
+    }
+  });
+}
+// src/main.ts
+program.name("lattice").description("Human-initiated, AI-powered knowledge graph for markdown documentation").version("0.1.0");
+registerSyncCommand(program);
+registerStatusCommand(program);
+registerQueryCommands(program);
+registerValidateCommand(program);
+registerOntologyCommand(program);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}