neuronlayer 0.1.9 → 0.2.0

package/dist/index.js

@@ -20822,7 +20822,7 @@ var StdioServerTransport = class {
 
 // src/core/engine.ts
 import { join as join13, basename as basename6 } from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, renameSync } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync11, renameSync } from "fs";
 
 // src/storage/database.ts
 import Database from "better-sqlite3";
@@ -21999,7 +21999,7 @@ var Tier3Storage = class {
 };
 
 // src/indexing/indexer.ts
-import { readFileSync as readFileSync2, statSync } from "fs";
+import { readFileSync as readFileSync3, statSync } from "fs";
 import { glob } from "glob";
 import { relative as relative2 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -22072,6 +22072,9 @@ var EmbeddingGenerator = class {
 };
 
 // src/indexing/ast.ts
+import Parser from "web-tree-sitter";
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { fileURLToPath } from "url";
 var LANGUAGE_CONFIGS = {
   typescript: {
     wasmFile: "tree-sitter-typescript.wasm",
@@ -22170,10 +22173,33 @@ var ASTParser = class {
   }
   async initialize() {
     if (this.initialized) return;
-    this.initialized = true;
+    try {
+      await Parser.init();
+      this.initialized = true;
+    } catch (error2) {
+      console.warn("Failed to initialize tree-sitter, will fall back to regex:", error2);
+    }
   }
-  async loadLanguage(_langName) {
-    return null;
+  async loadLanguage(langName) {
+    if (this.languages.has(langName)) {
+      return this.languages.get(langName);
+    }
+    const config2 = LANGUAGE_CONFIGS[langName];
+    if (!config2 || !this.initialized) return null;
+    try {
+      const wasmPath = fileURLToPath(import.meta.resolve(`tree-sitter-wasms/out/${config2.wasmFile}`));
+      if (!existsSync3(wasmPath)) {
+        console.warn(`WASM file not found for ${langName}: ${wasmPath}`);
+        return null;
+      }
+      const wasmData = readFileSync2(wasmPath);
+      const language = await Parser.Language.load(wasmData);
+      this.languages.set(langName, language);
+      return language;
+    } catch (error2) {
+      console.warn(`Failed to load tree-sitter language ${langName}:`, error2);
+      return null;
+    }
   }
   getLanguageForFile(filePath) {
     const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
@@ -22188,7 +22214,63 @@ var ASTParser = class {
     if (!this.initialized) {
       await this.initialize();
     }
-    return this.parseWithRegex(filePath, content);
+    let { symbols, imports, exports } = this.parseWithRegex(filePath, content);
+    const lang = this.getLanguageForFile(filePath);
+    if (lang && this.initialized) {
+      const language = await this.loadLanguage(lang);
+      if (language) {
+        try {
+          const tsResult = this.parseWithTreeSitter(filePath, content, language, lang);
+          if (tsResult.symbols.length > 0) {
+            symbols = tsResult.symbols;
+          }
+        } catch (error2) {
+          console.warn(`Tree-sitter parsing failed for ${filePath}, falling back to regex:`, error2);
+        }
+      }
+    }
+    return { symbols, imports, exports };
+  }
+  parseWithTreeSitter(filePath, content, language, langName) {
+    const parser = new Parser();
+    parser.setLanguage(language);
+    const tree = parser.parse(content);
+    const config2 = LANGUAGE_CONFIGS[langName];
+    const symbols = [];
+    const imports = [];
+    const exports = [];
+    if (!config2) return { symbols, imports, exports };
+    const runQuery = (queryString, kind) => {
+      try {
+        const query = language.query(queryString);
+        const matches = query.matches(tree.rootNode);
+        for (const match of matches) {
+          const nameCapture = match.captures.find((c) => c.name === "name");
+          if (nameCapture) {
+            const node = nameCapture.node;
+            const defNode = match.captures[0]?.node || node.parent || node;
+            symbols.push({
+              fileId: 0,
+              filePath,
+              kind,
+              name: node.text,
+              lineStart: defNode.startPosition.row + 1,
+              lineEnd: defNode.endPosition.row + 1,
+              // Check if parent or grandparent is an export statement, typical in TS/JS
+              exported: defNode.parent?.type === "export_statement" || defNode.parent?.parent?.type === "export_statement",
+              signature: content.slice(defNode.startIndex, defNode.endIndex).split("\\n")[0]
+            });
+          }
+        }
+      } catch (err) {
+        console.warn(`Query error for ${kind} in ${langName}:`, err);
+      }
+    };
+    if (config2.queries.functions) runQuery(config2.queries.functions, "function");
+    if (config2.queries.classes) runQuery(config2.queries.classes, "class");
+    if (config2.queries.interfaces) runQuery(config2.queries.interfaces, "interface");
+    if (config2.queries.types) runQuery(config2.queries.types, "type");
+    return { symbols, imports, exports };
   }
   // Regex-based parsing for symbol extraction
   // Handles: functions, classes, interfaces, types, imports, exports
@@ -23002,7 +23084,7 @@ var Indexer = class extends EventEmitter2 {
   }
   async indexFile(absolutePath) {
     try {
-      const content = readFileSync2(absolutePath, "utf-8");
+      const content = readFileSync3(absolutePath, "utf-8");
       const stats = statSync(absolutePath);
       const relativePath = relative2(this.config.projectPath, absolutePath);
       const contentHash = hashContent(content);
@@ -23460,7 +23542,7 @@ ${tags.join(" ")}`;
 
 // src/core/decision-extractor.ts
 import { execSync } from "child_process";
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
 import { join as join3 } from "path";
 import { glob as glob2 } from "glob";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -23501,7 +23583,7 @@ var DecisionExtractor = class {
   isGitRepo;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.isGitRepo = existsSync3(join3(projectPath, ".git"));
+    this.isGitRepo = existsSync4(join3(projectPath, ".git"));
   }
   async extractAll() {
     const decisions = [];
@@ -23575,7 +23657,7 @@ ${body}`.trim();
         });
         for (const file2 of files.slice(0, 100)) {
           try {
-            const content = readFileSync3(file2, "utf-8");
+            const content = readFileSync4(file2, "utf-8");
             const lines = content.split("\n");
             for (let i = 0; i < lines.length; i++) {
               const line = lines[i] || "";
@@ -23621,7 +23703,7 @@ ${body}`.trim();
         });
         for (const file2 of files) {
           try {
-            const content = readFileSync3(file2, "utf-8");
+            const content = readFileSync4(file2, "utf-8");
             const title = this.extractADRTitle(content);
             const status = this.extractADRStatus(content);
             if (title && status !== "superseded" && status !== "deprecated") {
@@ -24325,7 +24407,7 @@ var FileSummarizer = class {
 };
 
 // src/core/project-manager.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, readdirSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3, readdirSync } from "fs";
 import { join as join4, basename as basename2, resolve } from "path";
 import { createHash as createHash3 } from "crypto";
 import { homedir } from "os";
@@ -24337,15 +24419,15 @@ var ProjectManager = class {
   constructor() {
     this.baseDataDir = join4(homedir(), ".memorylayer");
     this.registryPath = join4(this.baseDataDir, "registry.json");
-    if (!existsSync4(this.baseDataDir)) {
-      mkdirSync3(this.baseDataDir, { recursive: true });
+    if (!existsSync5(this.baseDataDir)) {
+      mkdirSync4(this.baseDataDir, { recursive: true });
     }
     this.registry = this.loadRegistry();
   }
   loadRegistry() {
     try {
-      if (existsSync4(this.registryPath)) {
-        const data = JSON.parse(readFileSync4(this.registryPath, "utf-8"));
+      if (existsSync5(this.registryPath)) {
+        const data = JSON.parse(readFileSync5(this.registryPath, "utf-8"));
         return data;
       }
     } catch (error2) {
@@ -24359,7 +24441,7 @@ var ProjectManager = class {
   }
   saveRegistry() {
     try {
-      writeFileSync2(this.registryPath, JSON.stringify(this.registry, null, 2));
+      writeFileSync3(this.registryPath, JSON.stringify(this.registry, null, 2));
     } catch (error2) {
       console.error("Error saving registry:", error2);
     }
@@ -24378,7 +24460,7 @@ var ProjectManager = class {
     const normalizedPath = resolve(projectPath);
     const projectId = this.generateProjectId(normalizedPath);
     const dataDir = this.getProjectDataDir(normalizedPath);
-    if (!existsSync4(normalizedPath)) {
+    if (!existsSync5(normalizedPath)) {
       throw new Error(`Project path does not exist: ${normalizedPath}`);
     }
     const existingProject = this.registry.projects[projectId];
@@ -24498,7 +24580,7 @@ var ProjectManager = class {
       join4(homeDir, "Documents")
     ];
     for (const searchDir of searchDirs) {
-      if (!existsSync4(searchDir)) continue;
+      if (!existsSync5(searchDir)) continue;
       try {
         const entries = readdirSync(searchDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -24515,7 +24597,7 @@ var ProjectManager = class {
             ".git"
           ];
           const isProject = projectIndicators.some(
-            (indicator) => existsSync4(join4(projectPath, indicator))
+            (indicator) => existsSync5(join4(projectPath, indicator))
           );
           if (isProject) {
             discovered.push(projectPath);
@@ -24531,10 +24613,10 @@ var ProjectManager = class {
     const result = [];
     for (const project of this.listProjects()) {
       let dbPath = join4(project.dataDir, "neuronlayer.db");
-      if (!existsSync4(dbPath)) {
+      if (!existsSync5(dbPath)) {
         dbPath = join4(project.dataDir, "memorylayer.db");
       }
-      if (existsSync4(dbPath)) {
+      if (existsSync5(dbPath)) {
         try {
           const db = new Database2(dbPath, { readonly: true });
           result.push({ project, db });
@@ -24556,7 +24638,7 @@ var ProjectManager = class {
 };
 
 // src/core/adr-exporter.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
 var ADRExporter = class {
   projectPath;
@@ -24567,8 +24649,8 @@ var ADRExporter = class {
   exportDecision(decision, options = {}) {
     const outputDir = options.outputDir || join5(this.projectPath, "docs", "decisions");
     const format = options.format || "madr";
-    if (!existsSync5(outputDir)) {
-      mkdirSync4(outputDir, { recursive: true });
+    if (!existsSync6(outputDir)) {
+      mkdirSync5(outputDir, { recursive: true });
     }
     const existingFiles = this.getExistingADRFiles(outputDir);
     const nextNumber = this.getNextADRNumber(existingFiles);
@@ -24588,7 +24670,7 @@ var ADRExporter = class {
         content = this.formatSimple(decision, nextNumber);
         break;
     }
-    writeFileSync3(filePath, content);
+    writeFileSync4(filePath, content);
     return filePath;
   }
   // Export all decisions
@@ -24635,7 +24717,7 @@ var ADRExporter = class {
     lines.push("---");
     lines.push("");
     lines.push("*Generated by NeuronLayer*");
-    writeFileSync3(indexPath, lines.join("\n"));
+    writeFileSync4(indexPath, lines.join("\n"));
     return indexPath;
   }
   // MADR format (Markdown Any Decision Records)
@@ -24741,7 +24823,7 @@ ${decision.files.map((f) => `- \`${f}\``).join("\n")}
 `;
   }
   getExistingADRFiles(dir) {
-    if (!existsSync5(dir)) return [];
+    if (!existsSync6(dir)) return [];
     try {
       const { readdirSync: readdirSync4 } = __require("fs");
       return readdirSync4(dir).filter((f) => /^\d{4}-.*\.md$/.test(f)).sort();
@@ -24761,7 +24843,7 @@ ${decision.files.map((f) => `- \`${f}\``).join("\n")}
 
 // src/core/feature-context.ts
 import { EventEmitter as EventEmitter3 } from "events";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname4, join as join6, basename as basename3 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var MAX_FILES = 20;
@@ -24861,7 +24943,7 @@ var FeatureContextManager = class extends EventEmitter3 {
     if (this.fileContents.has(relativePath)) return;
     try {
       const absolutePath = this.toAbsolutePath(relativePath);
-      const content = readFileSync6(absolutePath, "utf-8");
+      const content = readFileSync7(absolutePath, "utf-8");
       this.fileContents.set(relativePath, content);
       if (this.fileContents.size > HOT_CACHE_MAX_FILES && this.current) {
         const filesInContext = new Set(this.current.files.map((f) => f.path));
@@ -25012,22 +25094,22 @@ var FeatureContextManager = class extends EventEmitter3 {
   save() {
     try {
       const dir = dirname4(this.persistPath);
-      if (!existsSync6(dir)) {
-        mkdirSync5(dir, { recursive: true });
+      if (!existsSync7(dir)) {
+        mkdirSync6(dir, { recursive: true });
       }
       const data = {
         current: this.current,
         recent: this.recent
       };
-      writeFileSync4(this.persistPath, JSON.stringify(data, null, 2));
+      writeFileSync5(this.persistPath, JSON.stringify(data, null, 2));
     } catch (error2) {
       console.error("Error saving feature context:", error2);
     }
   }
   load() {
     try {
-      if (existsSync6(this.persistPath)) {
-        const data = JSON.parse(readFileSync6(this.persistPath, "utf-8"));
+      if (existsSync7(this.persistPath)) {
+        const data = JSON.parse(readFileSync7(this.persistPath, "utf-8"));
         if (data.current) {
           this.current = this.parseContext(data.current);
         }
@@ -25272,7 +25354,7 @@ var FeatureContextManager = class extends EventEmitter3 {
 };
 
 // src/core/living-docs/architecture-generator.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, readdirSync as readdirSync2 } from "fs";
 import { basename as basename4, join as join7 } from "path";
 var ArchitectureGenerator = class _ArchitectureGenerator {
   projectPath;
@@ -25351,7 +25433,7 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
   detectLayers() {
     const layers = [];
     const layerMap = /* @__PURE__ */ new Map();
-    const srcDir = existsSync7(join7(this.projectPath, "src")) ? join7(this.projectPath, "src") : this.projectPath;
+    const srcDir = existsSync8(join7(this.projectPath, "src")) ? join7(this.projectPath, "src") : this.projectPath;
     try {
       const entries = readdirSync2(srcDir, { withFileTypes: true });
       for (const entry of entries) {
@@ -25537,9 +25619,9 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
   getProjectDependencies() {
     const deps = [];
     const packageJsonPath = join7(this.projectPath, "package.json");
-    if (existsSync7(packageJsonPath)) {
+    if (existsSync8(packageJsonPath)) {
       try {
-        const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
         if (pkg.dependencies) {
           for (const [name, version2] of Object.entries(pkg.dependencies)) {
             deps.push({
@@ -25565,9 +25647,9 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
       }
     }
     const requirementsPath = join7(this.projectPath, "requirements.txt");
-    if (existsSync7(requirementsPath)) {
+    if (existsSync8(requirementsPath)) {
       try {
-        const content = readFileSync7(requirementsPath, "utf-8");
+        const content = readFileSync8(requirementsPath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
         for (const line of lines.slice(0, 20)) {
           const match = line.match(/^([a-zA-Z0-9_-]+)(?:[=<>~!]+(.+))?/);
@@ -25608,7 +25690,7 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
 
 // src/core/living-docs/component-generator.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { basename as basename5, extname as extname2, join as join8 } from "path";
 var ComponentGenerator = class {
   projectPath;
@@ -25617,7 +25699,7 @@ var ComponentGenerator = class {
   constructor(projectPath, tier2) {
     this.projectPath = projectPath;
     this.tier2 = tier2;
-    this.isGitRepo = existsSync8(join8(projectPath, ".git"));
+    this.isGitRepo = existsSync9(join8(projectPath, ".git"));
   }
   async generate(filePath) {
     const file2 = this.tier2.getFile(filePath);
@@ -25785,7 +25867,7 @@ var ComponentGenerator = class {
 
 // src/core/living-docs/changelog-generator.ts
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join9 } from "path";
 var ChangelogGenerator = class {
   projectPath;
@@ -25794,7 +25876,7 @@ var ChangelogGenerator = class {
   constructor(projectPath, db) {
     this.projectPath = projectPath;
     this.db = db;
-    this.isGitRepo = existsSync9(join9(projectPath, ".git"));
+    this.isGitRepo = existsSync10(join9(projectPath, ".git"));
   }
   async generate(options = {}) {
     if (!this.isGitRepo) {
@@ -26240,7 +26322,7 @@ var DocValidator = class {
 
 // src/core/living-docs/activity-tracker.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { join as join10 } from "path";
 var ActivityTracker = class {
   projectPath;
@@ -26251,7 +26333,7 @@ var ActivityTracker = class {
     this.projectPath = projectPath;
     this.db = db;
     this.tier2 = tier2;
-    this.isGitRepo = existsSync10(join10(projectPath, ".git"));
+    this.isGitRepo = existsSync11(join10(projectPath, ".git"));
   }
   async whatHappened(since, scope) {
     const sinceDate = this.parseSinceString(since);
@@ -30466,7 +30548,7 @@ ${category.toUpperCase()}:`);
 };
 
 // src/core/test-awareness/test-indexer.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 import { join as join11 } from "path";
 
 // src/core/test-awareness/test-parser.ts
@@ -31030,9 +31112,9 @@ var TestIndexer = class {
   }
   detectFramework() {
     const packageJsonPath = join11(this.projectPath, "package.json");
-    if (existsSync11(packageJsonPath)) {
+    if (existsSync12(packageJsonPath)) {
       try {
-        const pkg = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
         const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
         if (allDeps["vitest"]) return "vitest";
         if (allDeps["jest"]) return "jest";
@@ -31042,21 +31124,21 @@ var TestIndexer = class {
     }
     const pytestConfigs = ["pytest.ini", "pyproject.toml", "setup.cfg", "conftest.py"];
     for (const config2 of pytestConfigs) {
-      if (existsSync11(join11(this.projectPath, config2))) {
-        const content = readFileSync8(join11(this.projectPath, config2), "utf-8");
+      if (existsSync12(join11(this.projectPath, config2))) {
+        const content = readFileSync9(join11(this.projectPath, config2), "utf-8");
         if (content.includes("[pytest]") || content.includes("pytest") || config2 === "conftest.py") {
           return "pytest";
         }
       }
     }
     const goMod = join11(this.projectPath, "go.mod");
-    if (existsSync11(goMod)) {
+    if (existsSync12(goMod)) {
       return "go";
     }
     const vitestConfigs = ["vitest.config.ts", "vitest.config.js", "vite.config.ts", "vite.config.js"];
     for (const config2 of vitestConfigs) {
-      if (existsSync11(join11(this.projectPath, config2))) {
-        const content = readFileSync8(join11(this.projectPath, config2), "utf-8");
+      if (existsSync12(join11(this.projectPath, config2))) {
+        const content = readFileSync9(join11(this.projectPath, config2), "utf-8");
         if (content.includes("vitest") || content.includes("test:")) {
           return "vitest";
         }
@@ -31064,7 +31146,7 @@ var TestIndexer = class {
     }
     const jestConfigs = ["jest.config.ts", "jest.config.js", "jest.config.json"];
     for (const config2 of jestConfigs) {
-      if (existsSync11(join11(this.projectPath, config2))) {
+      if (existsSync12(join11(this.projectPath, config2))) {
         return "jest";
       }
     }
@@ -31117,7 +31199,7 @@ var TestIndexer = class {
     const cached2 = this.testCache.get(relativePath);
     if (cached2) return cached2;
     try {
-      const content = readFileSync8(absolutePath, "utf-8");
+      const content = readFileSync9(absolutePath, "utf-8");
       const tests = this.parser.parseFile(content, relativePath, this.framework);
       this.testCache.set(relativePath, tests);
       return tests;
@@ -32868,7 +32950,7 @@ var DejaVuDetector = class {
 };
 
 // src/core/code-verifier.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { join as join12, dirname as dirname6, extname as extname4 } from "path";
 var SECURITY_PATTERNS2 = [
   // SQL Injection
@@ -33119,9 +33201,9 @@ var CodeVerifier = class {
   }
   loadPackageJson() {
     const packageJsonPath = join12(this.projectPath, "package.json");
-    if (existsSync12(packageJsonPath)) {
+    if (existsSync13(packageJsonPath)) {
       try {
-        this.packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+        this.packageJson = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
       } catch {
         this.packageJson = null;
       }
@@ -33272,7 +33354,7 @@ var CodeVerifier = class {
       const packageName = this.getPackageName(importPath);
       if (!packages.has(packageName)) {
         const nodeModulePath = join12(this.nodeModulesPath, packageName);
-        if (existsSync12(nodeModulePath)) {
+        if (existsSync13(nodeModulePath)) {
           issues.push({
             package: packageName,
             type: "unlisted",
@@ -33320,16 +33402,16 @@ var CodeVerifier = class {
     let found = false;
     for (const ext of possibleExtensions) {
       const fullPath = join12(baseDir, importPath + ext);
-      if (existsSync12(fullPath)) {
+      if (existsSync13(fullPath)) {
         found = true;
         break;
       }
     }
     if (!found) {
       const dirPath = join12(baseDir, importPath);
-      if (existsSync12(dirPath)) {
+      if (existsSync13(dirPath)) {
         for (const indexFile of possibleIndexes) {
-          if (existsSync12(join12(dirPath, indexFile))) {
+          if (existsSync13(join12(dirPath, indexFile))) {
             found = true;
             break;
           }
@@ -33348,7 +33430,7 @@ var CodeVerifier = class {
   verifyPackageImport(importPath, issues, warnings) {
     const packageName = this.getPackageName(importPath);
     const nodeModulePath = join12(this.nodeModulesPath, packageName);
-    if (!existsSync12(nodeModulePath)) {
+    if (!existsSync13(nodeModulePath)) {
       issues.push({
         import: importPath,
         type: "missing_package",
@@ -33363,15 +33445,15 @@ var CodeVerifier = class {
       const possibleExtensions = [".js", ".json", ""];
       let found = false;
       for (const ext of possibleExtensions) {
-        if (existsSync12(subpathFull + ext)) {
+        if (existsSync13(subpathFull + ext)) {
           found = true;
           break;
         }
       }
       const pkgJsonPath = join12(nodeModulePath, "package.json");
-      if (!found && existsSync12(pkgJsonPath)) {
+      if (!found && existsSync13(pkgJsonPath)) {
         try {
-          const pkgJson = JSON.parse(readFileSync9(pkgJsonPath, "utf-8"));
+          const pkgJson = JSON.parse(readFileSync10(pkgJsonPath, "utf-8"));
           if (pkgJson.exports) {
             const exportKey = "./" + subpath;
             if (pkgJson.exports[exportKey] || pkgJson.exports["./" + subpath + ".js"]) {
@@ -33790,12 +33872,12 @@ var NeuronLayerEngine = class {
   indexingProgress = { indexed: 0, total: 0 };
   constructor(config2) {
     this.config = config2;
-    if (!existsSync13(config2.dataDir)) {
-      mkdirSync6(config2.dataDir, { recursive: true });
+    if (!existsSync14(config2.dataDir)) {
+      mkdirSync7(config2.dataDir, { recursive: true });
     }
     let dbPath = join13(config2.dataDir, "neuronlayer.db");
     const oldDbPath = join13(config2.dataDir, "memorylayer.db");
-    if (!existsSync13(dbPath) && existsSync13(oldDbPath)) {
+    if (!existsSync14(dbPath) && existsSync14(oldDbPath)) {
       try {
         console.error("Migrating database from memorylayer.db to neuronlayer.db...");
         renameSync(oldDbPath, dbPath);
@@ -34130,13 +34212,13 @@ ${description}`,
   async getFileContext(filePath) {
     this.activityGate.recordActivity();
     const absolutePath = join13(this.config.projectPath, filePath);
-    if (!existsSync13(absolutePath)) {
+    if (!existsSync14(absolutePath)) {
       return null;
     }
     try {
       let content = this.learningEngine.getFromHotCache(filePath);
       if (!content) {
-        content = readFileSync10(absolutePath, "utf-8");
+        content = readFileSync11(absolutePath, "utf-8");
         this.learningEngine.addToHotCache(filePath, content);
       }
       const language = detectLanguage(filePath);
@@ -34216,7 +34298,7 @@ ${decision.description}`;
     const commonDirs = ["src", "lib", "app", "pages", "components", "api", "server", "client", "core"];
     const found = [];
     for (const dir of commonDirs) {
-      if (existsSync13(join13(this.config.projectPath, dir))) {
+      if (existsSync14(join13(this.config.projectPath, dir))) {
         found.push(dir);
       }
     }
@@ -34225,9 +34307,9 @@ ${decision.description}`;
   detectDependencies() {
     const deps = [];
     const packageJsonPath = join13(this.config.projectPath, "package.json");
-    if (existsSync13(packageJsonPath)) {
+    if (existsSync14(packageJsonPath)) {
       try {
-        const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
         const allDeps = {
           ...pkg.dependencies,
           ...pkg.devDependencies
@@ -34237,9 +34319,9 @@ ${decision.description}`;
       }
     }
     const requirementsPath = join13(this.config.projectPath, "requirements.txt");
-    if (existsSync13(requirementsPath)) {
+    if (existsSync14(requirementsPath)) {
       try {
-        const content = readFileSync10(requirementsPath, "utf-8");
+        const content = readFileSync11(requirementsPath, "utf-8");
         const lines = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => l.split(/[=<>]/)[0]?.trim()).filter((l) => !!l);
         deps.push(...lines.slice(0, 20));
       } catch {
@@ -34302,9 +34384,9 @@ ${decision.description}`;
     for (const filePath of predicted) {
       if (!this.learningEngine.isInHotCache(filePath)) {
         const absolutePath = join13(this.config.projectPath, filePath);
-        if (existsSync13(absolutePath)) {
+        if (existsSync14(absolutePath)) {
           try {
-            const content = readFileSync10(absolutePath, "utf-8");
+            const content = readFileSync11(absolutePath, "utf-8");
             this.learningEngine.addToHotCache(filePath, content);
             fetched++;
           } catch {
@@ -38971,7 +39053,7 @@ function parseArgs(args) {
 
 // src/cli/commands.ts
 import { join as join15 } from "path";
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir2 } from "os";
 var projectManager = new ProjectManager();
 function listProjects() {
@@ -39087,9 +39169,9 @@ function exportDecisions(projectPath, options = {}) {
     };
   }
   let dbPath = join15(projectInfo.dataDir, "neuronlayer.db");
-  if (!existsSync14(dbPath)) {
+  if (!existsSync15(dbPath)) {
     const oldDbPath = join15(projectInfo.dataDir, "memorylayer.db");
-    if (existsSync14(oldDbPath)) {
+    if (existsSync15(oldDbPath)) {
       dbPath = oldDbPath;
     } else {
       return {
@@ -39152,13 +39234,13 @@ function showProject(projectId) {
 function configureMCPClient(clientName, configPath, serverName, projectPath) {
   let config2 = { mcpServers: {} };
   try {
-    if (existsSync14(configPath)) {
-      const content = readFileSync11(configPath, "utf-8");
+    if (existsSync15(configPath)) {
+      const content = readFileSync12(configPath, "utf-8");
       config2 = JSON.parse(content);
     } else {
       const sep = process.platform === "win32" ? "\\" : "/";
       const configDir = configPath.substring(0, configPath.lastIndexOf(sep));
-      mkdirSync7(configDir, { recursive: true });
+      mkdirSync8(configDir, { recursive: true });
     }
   } catch {
   }
@@ -39170,7 +39252,7 @@ function configureMCPClient(clientName, configPath, serverName, projectPath) {
     args: ["-y", "neuronlayer", "--project", projectPath]
   };
   try {
-    writeFileSync5(configPath, JSON.stringify(config2, null, 2));
+    writeFileSync6(configPath, JSON.stringify(config2, null, 2));
     return { success: true, message: `${clientName}: ${configPath}` };
   } catch (err) {
     return { success: false, message: `${clientName}: Failed - ${err instanceof Error ? err.message : String(err)}` };
@@ -39179,8 +39261,8 @@ function configureMCPClient(clientName, configPath, serverName, projectPath) {
 function configureProjectMCP(configPath, projectPath) {
   let config2 = { mcpServers: {} };
   try {
-    if (existsSync14(configPath)) {
-      const content = readFileSync11(configPath, "utf-8");
+    if (existsSync15(configPath)) {
+      const content = readFileSync12(configPath, "utf-8");
       config2 = JSON.parse(content);
     }
   } catch {
@@ -39193,7 +39275,7 @@ function configureProjectMCP(configPath, projectPath) {
     args: ["-y", "neuronlayer", "--project", "."]
   };
   try {
-    writeFileSync5(configPath, JSON.stringify(config2, null, 2));
+    writeFileSync6(configPath, JSON.stringify(config2, null, 2));
     return { success: true, message: `Claude Code: ${configPath} (project-local)` };
   } catch (err) {
     return { success: false, message: `Claude Code: Failed - ${err instanceof Error ? err.message : String(err)}` };