neuronlayer 0.1.6 → 0.1.8

package/dist/index.js

@@ -20821,8 +20821,8 @@ var StdioServerTransport = class {
 };
 
 // src/core/engine.ts
-import { join as join14, basename as basename6 } from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10 } from "fs";
+import { join as join13, basename as basename6 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, renameSync } from "fs";
 
 // src/storage/database.ts
 import Database from "better-sqlite3";
@@ -21677,9 +21677,20 @@ var Tier2Storage = class {
       SELECT DISTINCT i.file_id as fileId, f.path as filePath
       FROM imports i
       JOIN files f ON i.file_id = f.id
-      WHERE i.imported_from LIKE ?
+      WHERE i.imported_from = ?
+         OR i.imported_from LIKE ?
+         OR i.imported_from LIKE ?
+         OR i.imported_from LIKE ?
     `);
-    return stmt.all(`%${modulePath}%`);
+    return stmt.all(
+      modulePath,
+      `%/${modulePath}`,
+      // ends with /modulePath
+      `./${modulePath}`,
+      // relative ./modulePath
+      `../${modulePath}`
+      // parent ../modulePath
+    );
   }
   // Phase 2: Export operations
   clearExports(fileId) {
@@ -21735,7 +21746,10 @@ var Tier2Storage = class {
     const deps = [];
     for (const importer of importers) {
       const imports = this.getImportsByFile(importer.fileId);
-      const relevantImport = imports.find((i) => i.importedFrom.includes(fileName));
+      const relevantImport = imports.find((i) => {
+        const importedName = i.importedFrom.split(/[/\\]/).pop()?.replace(/\.[^.]+$/, "") || "";
+        return importedName === fileName || i.importedFrom.endsWith(`/${fileName}`) || i.importedFrom.endsWith(`./${fileName}`);
+      });
       if (relevantImport) {
         deps.push({
           file: importer.filePath,
@@ -21745,6 +21759,161 @@ var Tier2Storage = class {
     }
     return deps;
   }
+  /**
+   * Get ALL files affected by a change, walking the dependency graph.
+   * depth=1 is direct importers only. depth=3 catches ripple effects.
+   */
+  getTransitiveDependents(filePath, maxDepth = 3) {
+    const visited = /* @__PURE__ */ new Map();
+    const queue = [{ path: filePath, depth: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.depth >= maxDepth) continue;
+      if (visited.has(current.path) && visited.get(current.path).depth <= current.depth) continue;
+      const dependents = this.getFileDependents(current.path);
+      for (const dep of dependents) {
+        const existingDepth = visited.get(dep.file)?.depth ?? Infinity;
+        const newDepth = current.depth + 1;
+        if (newDepth < existingDepth) {
+          visited.set(dep.file, { depth: newDepth, imports: dep.imports });
+          queue.push({ path: dep.file, depth: newDepth });
+        }
+      }
+    }
+    visited.delete(filePath);
+    return Array.from(visited.entries()).map(([file2, info]) => ({ file: file2, ...info })).sort((a, b) => a.depth - b.depth);
+  }
+  /**
+   * Get the full import graph as an adjacency list.
+   * Returns { file → [files it imports] } for the whole project.
+   */
+  getFullDependencyGraph() {
+    const stmt = this.db.prepare(`
+      SELECT f.path as filePath, i.imported_from as importedFrom
+      FROM imports i
+      JOIN files f ON i.file_id = f.id
+    `);
+    const rows = stmt.all();
+    const graph = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      if (!graph.has(row.filePath)) graph.set(row.filePath, []);
+      graph.get(row.filePath).push(row.importedFrom);
+    }
+    return graph;
+  }
+  /**
+   * Find circular dependencies in the project.
+   * Returns arrays of file paths that form cycles.
+   */
+  findCircularDependencies() {
+    const graph = this.getFullDependencyGraph();
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const stack = /* @__PURE__ */ new Set();
+    const dfs = (node, path) => {
+      if (stack.has(node)) {
+        const cycleStart = path.indexOf(node);
+        if (cycleStart >= 0) {
+          cycles.push(path.slice(cycleStart).concat(node));
+        }
+        return;
+      }
+      if (visited.has(node)) return;
+      visited.add(node);
+      stack.add(node);
+      path.push(node);
+      const deps = graph.get(node) || [];
+      for (const dep of deps) {
+        const resolved = this.resolveImportPath(node, dep);
+        if (resolved) dfs(resolved, [...path]);
+      }
+      stack.delete(node);
+    };
+    for (const file2 of graph.keys()) {
+      dfs(file2, []);
+    }
+    const uniqueCycles = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const cycle of cycles) {
+      const normalized = [...cycle].sort().join("|");
+      if (!seen.has(normalized)) {
+        seen.add(normalized);
+        uniqueCycles.push(cycle);
+      }
+    }
+    return uniqueCycles;
+  }
+  /**
+   * Resolve a relative import path to an actual file path in the database.
+   */
+  resolveImportPath(fromFile, importPath) {
+    if (!importPath.startsWith(".") && !importPath.startsWith("/")) return null;
+    const dir = fromFile.split(/[/\\]/).slice(0, -1).join("/");
+    let resolved = importPath;
+    if (importPath.startsWith("./")) {
+      resolved = dir + "/" + importPath.slice(2);
+    } else if (importPath.startsWith("../")) {
+      const parts = dir.split("/");
+      let impParts = importPath.split("/");
+      while (impParts[0] === "..") {
+        parts.pop();
+        impParts.shift();
+      }
+      resolved = parts.join("/") + "/" + impParts.join("/");
+    }
+    const baseName = resolved.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+    const stmt = this.db.prepare(`
+      SELECT path FROM files
+      WHERE path = ? OR path = ? OR path = ? OR path = ?
+         OR path = ? OR path = ?
+      LIMIT 1
+    `);
+    const result = stmt.get(
+      `${baseName}.ts`,
+      `${baseName}.tsx`,
+      `${baseName}.js`,
+      `${baseName}.jsx`,
+      `${baseName}/index.ts`,
+      `${baseName}/index.js`
+    );
+    return result?.path || null;
+  }
+  /**
+   * Resolve an import path to a file record in the database.
+   * Used by indexer to build the dependencies table.
+   */
+  resolveImportToFile(sourceFilePath, importPath) {
+    if (!importPath.startsWith(".") && !importPath.startsWith("/")) return null;
+    const sourceDir = sourceFilePath.split(/[/\\]/).slice(0, -1).join("/");
+    let resolved = importPath;
+    if (importPath.startsWith("./")) {
+      resolved = sourceDir + "/" + importPath.slice(2);
+    } else if (importPath.startsWith("../")) {
+      const parts = sourceDir.split("/");
+      let impParts = importPath.split("/");
+      while (impParts[0] === "..") {
+        parts.pop();
+        impParts.shift();
+      }
+      resolved = parts.join("/") + "/" + impParts.join("/");
+    }
+    resolved = resolved.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+    const stmt = this.db.prepare(`
+      SELECT id, path FROM files
+      WHERE path = ? OR path = ? OR path = ? OR path = ?
+         OR path = ? OR path = ?
+      LIMIT 1
+    `);
+    const result = stmt.get(
+      `${resolved}.ts`,
+      `${resolved}.tsx`,
+      `${resolved}.js`,
+      `${resolved}.jsx`,
+      `${resolved}/index.ts`,
+      `${resolved}/index.js`
+    );
+    return result || null;
+  }
 };
 
 // src/storage/tier3.ts
@@ -21903,8 +22072,6 @@ var EmbeddingGenerator = class {
 };
 
 // src/indexing/ast.ts
-import Parser from "web-tree-sitter";
-import { join as join2 } from "path";
 var LANGUAGE_CONFIGS = {
   typescript: {
     wasmFile: "tree-sitter-typescript.wasm",
@@ -21967,6 +22134,30 @@ var LANGUAGE_CONFIGS = {
         (import_from_statement) @import
       `
     }
+  },
+  go: {
+    wasmFile: "tree-sitter-go.wasm",
+    extensions: [".go"],
+    queries: {
+      functions: `(function_declaration name: (identifier) @name) @func`,
+      classes: `(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @class`
+    }
+  },
+  rust: {
+    wasmFile: "tree-sitter-rust.wasm",
+    extensions: [".rs"],
+    queries: {
+      functions: `(function_item name: (identifier) @name) @func`,
+      classes: `(struct_item name: (type_identifier) @name) @class`
+    }
+  },
+  java: {
+    wasmFile: "tree-sitter-java.wasm",
+    extensions: [".java"],
+    queries: {
+      functions: `(method_declaration name: (identifier) @name) @func`,
+      classes: `(class_declaration name: (identifier) @name) @class`
+    }
   }
 };
 var ASTParser = class {
@@ -21979,33 +22170,10 @@ var ASTParser = class {
   }
   async initialize() {
     if (this.initialized) return;
-    try {
-      await Parser.init();
-      this.parser = new Parser();
-      this.initialized = true;
-      console.error("AST Parser initialized");
-    } catch (error2) {
-      console.error("Failed to initialize AST parser:", error2);
-      throw error2;
-    }
+    this.initialized = true;
   }
-  async loadLanguage(langName) {
-    if (this.languages.has(langName)) {
-      return this.languages.get(langName);
-    }
-    const config2 = LANGUAGE_CONFIGS[langName];
-    if (!config2) {
-      return null;
-    }
-    try {
-      const wasmDir = join2(this.dataDir, "wasm");
-      const wasmPath = join2(wasmDir, config2.wasmFile);
-      console.error(`Language ${langName} WASM not available yet`);
-      return null;
-    } catch (error2) {
-      console.error(`Failed to load language ${langName}:`, error2);
-      return null;
-    }
+  async loadLanguage(_langName) {
+    return null;
   }
   getLanguageForFile(filePath) {
     const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
@@ -22022,7 +22190,9 @@ var ASTParser = class {
     }
     return this.parseWithRegex(filePath, content);
   }
-  // Regex-based parsing fallback (works without WASM)
+  // Regex-based parsing for symbol extraction
+  // Handles: functions, classes, interfaces, types, imports, exports
+  // Supports: TypeScript, JavaScript, Python, Go, Rust, Java
   parseWithRegex(filePath, content) {
     const symbols = [];
     const imports = [];
@@ -22033,39 +22203,62 @@ var ASTParser = class {
       this.parseTypeScriptJS(filePath, content, lines, symbols, imports, exports);
     } else if (lang === "python") {
       this.parsePython(filePath, content, lines, symbols, imports, exports);
+    } else if (lang === "go") {
+      this.parseGo(filePath, content, lines, symbols, imports, exports);
+    } else if (lang === "rust") {
+      this.parseRust(filePath, content, lines, symbols, imports, exports);
+    } else if (lang === "java") {
+      this.parseJava(filePath, content, lines, symbols, imports, exports);
     }
     return { symbols, imports, exports };
   }
   parseTypeScriptJS(filePath, content, lines, symbols, imports, exports) {
     const patterns = {
-      // Functions: function name(), const name = () =>, const name = function()
-      function: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
-      arrowFunc: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
+      // Functions: function name(), export default function name(), const name = () =>
+      function: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/,
+      // Arrow functions: handles type annotations and destructured params
+      arrowFunc: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?::\s*[^=]+)?\s*=>/,
       // Classes
-      class: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/,
+      class: /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/,
       // Interfaces (TS only)
       interface: /^(?:export\s+)?interface\s+(\w+)/,
       // Types (TS only)
-      type: /^(?:export\s+)?type\s+(\w+)\s*=/,
-      // Imports
-      import: /^import\s+(?:(\w+)(?:\s*,\s*)?)?(?:\{([^}]+)\})?\s*from\s*['"]([^'"]+)['"]/,
-      importAll: /^import\s+\*\s+as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/,
+      type: /^(?:export\s+)?type\s+(\w+)\s*(?:<[^>]*>)?\s*=/,
+      // Imports - supports 'import type'
+      import: /^import\s+(?:type\s+)?(?:(\w+)(?:\s*,\s*)?)?(?:\{([^}]+)\})?\s*from\s*['"]([^'"]+)['"]/,
+      importAll: /^import\s+(?:type\s+)?\*\s+as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/,
       importSideEffect: /^import\s*['"]([^'"]+)['"]/,
       // Exports
-      exportNamed: /^export\s+\{([^}]+)\}/,
+      exportNamed: /^export\s+(?:type\s+)?\{([^}]+)\}/,
       exportDefault: /^export\s+default\s+(?:class|function|const|let|var)?\s*(\w+)?/,
       exportDirect: /^export\s+(?:const|let|var|function|class|interface|type|enum|async\s+function)\s+(\w+)/,
       // Enums (TS)
       enum: /^(?:export\s+)?(?:const\s+)?enum\s+(\w+)/,
-      // Methods inside classes (simplified)
-      method: /^\s+(?:async\s+)?(?:static\s+)?(?:private\s+|public\s+|protected\s+)?(\w+)\s*\([^)]*\)\s*[:{]/
+      // Methods inside classes - handles generics, readonly, and all modifiers
+      method: /^\s+(?:async\s+)?(?:static\s+)?(?:readonly\s+)?(?:private\s+|public\s+|protected\s+)?(?:get\s+|set\s+)?(\w+)\s*(?:<[^>]+>)?\s*\(/
     };
     let currentClass = null;
     let braceDepth = 0;
+    let inBlockComment = false;
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] || "";
       const trimmed = line.trim();
       const lineNum = i + 1;
+      if (inBlockComment) {
+        if (trimmed.includes("*/")) {
+          inBlockComment = false;
+        }
+        continue;
+      }
+      if (trimmed.startsWith("//")) {
+        continue;
+      }
+      if (trimmed.startsWith("/*")) {
+        if (!trimmed.includes("*/")) {
+          inBlockComment = true;
+        }
+        continue;
+      }
       braceDepth += (line.match(/\{/g) || []).length;
       braceDepth -= (line.match(/\}/g) || []).length;
       if (currentClass && braceDepth === 0) {
@@ -22075,9 +22268,6 @@ var ASTParser = class {
         }
         currentClass = null;
       }
-      if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
-        continue;
-      }
       let match = trimmed.match(patterns.function);
       if (match && match[1]) {
         symbols.push({
@@ -22314,6 +22504,224 @@ var ASTParser = class {
       }
     }
   }
+  parseGo(filePath, content, lines, symbols, imports, exports) {
+    let inImportBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || "";
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+      if (trimmed.startsWith("//")) continue;
+      if (trimmed === "import (") {
+        inImportBlock = true;
+        continue;
+      }
+      if (inImportBlock && trimmed === ")") {
+        inImportBlock = false;
+        continue;
+      }
+      const importMatch = inImportBlock ? trimmed.match(/^(?:(\w+)\s+)?"([^"]+)"/) : trimmed.match(/^import\s+(?:(\w+)\s+)?"([^"]+)"/);
+      if (importMatch) {
+        const alias = importMatch[1];
+        const path = importMatch[2] || "";
+        const pkg = alias || path.split("/").pop() || "";
+        imports.push({
+          fileId: 0,
+          filePath,
+          importedFrom: path,
+          importedSymbols: [pkg],
+          isDefault: false,
+          isNamespace: false,
+          lineNumber: lineNum
+        });
+        continue;
+      }
+      const funcMatch = trimmed.match(/^func\s+(?:\((\w+)\s+\*?(\w+)\)\s+)?(\w+)\s*\(/);
+      if (funcMatch) {
+        const receiver = funcMatch[2];
+        const name = receiver ? `${receiver}.${funcMatch[3]}` : funcMatch[3] || "";
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: receiver ? "method" : "function",
+          name,
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: /^[A-Z]/.test(funcMatch[3] || ""),
+          signature: trimmed.split("{")[0]?.trim()
+        });
+        continue;
+      }
+      const structMatch = trimmed.match(/^type\s+(\w+)\s+struct\s*\{?/);
+      if (structMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "class",
+          name: structMatch[1] || "",
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: /^[A-Z]/.test(structMatch[1] || "")
+        });
+        continue;
+      }
+      const ifaceMatch = trimmed.match(/^type\s+(\w+)\s+interface\s*\{?/);
+      if (ifaceMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "interface",
+          name: ifaceMatch[1] || "",
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: /^[A-Z]/.test(ifaceMatch[1] || "")
+        });
+      }
+    }
+  }
+  parseRust(filePath, content, lines, symbols, imports, exports) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || "";
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+      if (trimmed.startsWith("//")) continue;
+      const fnMatch = trimmed.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+      if (fnMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "function",
+          name: fnMatch[1] || "",
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith("pub"),
+          signature: trimmed.split("{")[0]?.trim()
+        });
+        continue;
+      }
+      const structMatch = trimmed.match(/^(?:pub\s+)?struct\s+(\w+)/);
+      if (structMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "class",
+          name: structMatch[1] || "",
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith("pub")
+        });
+        continue;
+      }
+      const enumMatch = trimmed.match(/^(?:pub\s+)?enum\s+(\w+)/);
+      if (enumMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "enum",
+          name: enumMatch[1] || "",
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith("pub")
+        });
+        continue;
+      }
+      const traitMatch = trimmed.match(/^(?:pub\s+)?trait\s+(\w+)/);
+      if (traitMatch) {
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "interface",
+          name: traitMatch[1] || "",
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.startsWith("pub")
+        });
+        continue;
+      }
+      const implMatch = trimmed.match(/^impl\s+(?:<[^>]+>\s+)?(?:(\w+)\s+for\s+)?(\w+)/);
+      if (implMatch) {
+        const traitName = implMatch[1];
+        const typeName = implMatch[2] || "";
+        const name = traitName ? `${traitName} for ${typeName}` : typeName;
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: "class",
+          name: `impl ${name}`,
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: false
+        });
+        continue;
+      }
+      const useMatch = trimmed.match(/^(?:pub\s+)?use\s+(.+);/);
+      if (useMatch) {
+        const path = (useMatch[1] || "").replace(/::/g, "/");
+        imports.push({
+          fileId: 0,
+          filePath,
+          importedFrom: path,
+          importedSymbols: [path.split("/").pop()?.replace(/[{}]/g, "") || ""],
+          isDefault: false,
+          isNamespace: path.includes("*"),
+          lineNumber: lineNum
+        });
+      }
+    }
+  }
+  parseJava(filePath, content, lines, symbols, imports, exports) {
+    let currentClass = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] || "";
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+      if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+      const importMatch = trimmed.match(/^import\s+(?:static\s+)?([^;]+);/);
+      if (importMatch) {
+        const path = importMatch[1] || "";
+        imports.push({
+          fileId: 0,
+          filePath,
+          importedFrom: path,
+          importedSymbols: [path.split(".").pop() || ""],
+          isDefault: false,
+          isNamespace: path.endsWith("*"),
+          lineNumber: lineNum
+        });
+        continue;
+      }
+      const classMatch = trimmed.match(/^(?:public\s+|private\s+|protected\s+)?(?:abstract\s+)?(?:final\s+)?(class|interface|enum)\s+(\w+)/);
+      if (classMatch) {
+        currentClass = classMatch[2] || "";
+        symbols.push({
+          fileId: 0,
+          filePath,
+          kind: classMatch[1] === "interface" ? "interface" : classMatch[1] === "enum" ? "enum" : "class",
+          name: currentClass,
+          lineStart: lineNum,
+          lineEnd: this.findBlockEnd(lines, i),
+          exported: trimmed.includes("public")
+        });
+        continue;
+      }
+      const methodMatch = trimmed.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:abstract\s+)?(?:<[^>]+>\s+)?(\w+(?:<[^>]+>)?)\s+(\w+)\s*\(/);
+      if (methodMatch && currentClass && !["if", "for", "while", "switch", "catch", "class", "interface", "enum"].includes(methodMatch[2] || "")) {
+        const returnType = methodMatch[1];
+        const methodName = methodMatch[2] || "";
+        if (methodName !== currentClass) {
+          symbols.push({
+            fileId: 0,
+            filePath,
+            kind: "method",
+            name: `${currentClass}.${methodName}`,
+            lineStart: lineNum,
+            lineEnd: this.findBlockEnd(lines, i),
+            exported: trimmed.includes("public"),
+            signature: `${returnType} ${methodName}(...)`
+          });
+        }
+      }
+    }
+  }
   findBlockEnd(lines, startIndex) {
     let braceCount = 0;
     let started = false;
@@ -22634,11 +23042,31 @@ var Indexer = class extends EventEmitter2 {
             const exportsWithFileId = parsed.exports.map((e) => ({ ...e, fileId }));
             this.tier2.insertExports(exportsWithFileId);
           }
+          if (parsed.imports.length > 0) {
+            this.tier2.clearDependencies(fileId);
+            for (const imp of parsed.imports) {
+              const targetFile = this.tier2.resolveImportToFile(relativePath, imp.importedFrom);
+              if (targetFile) {
+                this.tier2.addDependency(fileId, targetFile.id, "imports");
+              }
+            }
+          }
         }
       } catch (astError) {
         console.error(`AST parsing failed for ${relativePath}:`, astError);
       }
       this.emit("fileIndexed", relativePath);
+      if (!this.isIndexing) {
+        const dependents = this.tier2.getFileDependents(relativePath);
+        if (dependents.length > 0) {
+          this.emit("fileImpact", {
+            file: relativePath,
+            affectedFiles: dependents.map((d) => d.file),
+            affectedCount: dependents.length,
+            imports: dependents.map((d) => ({ file: d.file, symbols: d.imports }))
+          });
+        }
+      }
       return true;
     } catch (error2) {
       console.error(`Error indexing ${absolutePath}:`, error2);
@@ -22735,7 +23163,7 @@ var Indexer = class extends EventEmitter2 {
 };
 
 // src/core/context.ts
-import { dirname as dirname4, basename } from "path";
+import { dirname as dirname3, basename } from "path";
 
 // src/utils/tokens.ts
 var AVG_CHARS_PER_TOKEN = 4;
@@ -22931,7 +23359,7 @@ ${result.preview}
     const filesViewed = this.tier1.getFilesViewed();
     return results.map((r) => {
       let score = r.similarity;
-      if (currentFile && dirname4(r.file) === dirname4(currentFile)) {
+      if (currentFile && dirname3(r.file) === dirname3(currentFile)) {
         score *= 1.5;
       }
       const hoursSinceModified = (Date.now() - r.lastModified) / 36e5;
@@ -23033,7 +23461,7 @@ ${tags.join(" ")}`;
 // src/core/decision-extractor.ts
 import { execSync } from "child_process";
 import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 import { glob as glob2 } from "glob";
 import { randomUUID as randomUUID2 } from "crypto";
 var COMMIT_PATTERNS = [
@@ -23073,7 +23501,7 @@ var DecisionExtractor = class {
   isGitRepo;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.isGitRepo = existsSync3(join4(projectPath, ".git"));
+    this.isGitRepo = existsSync3(join3(projectPath, ".git"));
   }
   async extractAll() {
     const decisions = [];
@@ -23898,7 +24326,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 { join as join5, basename as basename2, resolve } from "path";
+import { join as join4, basename as basename2, resolve } from "path";
 import { createHash as createHash3 } from "crypto";
 import { homedir } from "os";
 import Database2 from "better-sqlite3";
@@ -23907,8 +24335,8 @@ var ProjectManager = class {
   registry;
   baseDataDir;
   constructor() {
-    this.baseDataDir = join5(homedir(), ".memorylayer");
-    this.registryPath = join5(this.baseDataDir, "registry.json");
+    this.baseDataDir = join4(homedir(), ".memorylayer");
+    this.registryPath = join4(this.baseDataDir, "registry.json");
     if (!existsSync4(this.baseDataDir)) {
       mkdirSync3(this.baseDataDir, { recursive: true });
     }
@@ -23943,7 +24371,7 @@ var ProjectManager = class {
   getProjectDataDir(projectPath) {
     const projectId = this.generateProjectId(projectPath);
     const projectName = basename2(projectPath);
-    return join5(this.baseDataDir, "projects", `${projectName}-${projectId}`);
+    return join4(this.baseDataDir, "projects", `${projectName}-${projectId}`);
   }
   // Register a new project or update existing
   registerProject(projectPath) {
@@ -24057,17 +24485,17 @@ var ProjectManager = class {
     const discovered = [];
     const homeDir = homedir();
     const searchDirs = [
-      join5(homeDir, "projects"),
-      join5(homeDir, "Projects"),
-      join5(homeDir, "code"),
-      join5(homeDir, "Code"),
-      join5(homeDir, "dev"),
-      join5(homeDir, "Development"),
-      join5(homeDir, "workspace"),
-      join5(homeDir, "repos"),
-      join5(homeDir, "github"),
-      join5(homeDir, "Desktop"),
-      join5(homeDir, "Documents")
+      join4(homeDir, "projects"),
+      join4(homeDir, "Projects"),
+      join4(homeDir, "code"),
+      join4(homeDir, "Code"),
+      join4(homeDir, "dev"),
+      join4(homeDir, "Development"),
+      join4(homeDir, "workspace"),
+      join4(homeDir, "repos"),
+      join4(homeDir, "github"),
+      join4(homeDir, "Desktop"),
+      join4(homeDir, "Documents")
     ];
     for (const searchDir of searchDirs) {
       if (!existsSync4(searchDir)) continue;
@@ -24075,7 +24503,7 @@ var ProjectManager = class {
         const entries = readdirSync(searchDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
-          const projectPath = join5(searchDir, entry.name);
+          const projectPath = join4(searchDir, entry.name);
           const projectIndicators = [
             "package.json",
             "Cargo.toml",
@@ -24087,7 +24515,7 @@ var ProjectManager = class {
             ".git"
           ];
           const isProject = projectIndicators.some(
-            (indicator) => existsSync4(join5(projectPath, indicator))
+            (indicator) => existsSync4(join4(projectPath, indicator))
           );
           if (isProject) {
             discovered.push(projectPath);
@@ -24102,7 +24530,10 @@ var ProjectManager = class {
   getProjectDatabases() {
     const result = [];
     for (const project of this.listProjects()) {
-      const dbPath = join5(project.dataDir, "memorylayer.db");
+      let dbPath = join4(project.dataDir, "neuronlayer.db");
+      if (!existsSync4(dbPath)) {
+        dbPath = join4(project.dataDir, "memorylayer.db");
+      }
       if (existsSync4(dbPath)) {
         try {
           const db = new Database2(dbPath, { readonly: true });
@@ -24126,7 +24557,7 @@ var ProjectManager = class {
 
 // src/core/adr-exporter.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 var ADRExporter = class {
   projectPath;
   constructor(projectPath) {
@@ -24134,7 +24565,7 @@ var ADRExporter = class {
   }
   // Export a single decision to ADR file
   exportDecision(decision, options = {}) {
-    const outputDir = options.outputDir || join6(this.projectPath, "docs", "decisions");
+    const outputDir = options.outputDir || join5(this.projectPath, "docs", "decisions");
     const format = options.format || "madr";
     if (!existsSync5(outputDir)) {
       mkdirSync4(outputDir, { recursive: true });
@@ -24143,7 +24574,7 @@ var ADRExporter = class {
     const nextNumber = this.getNextADRNumber(existingFiles);
     const slug = this.slugify(decision.title);
     const filename = `${String(nextNumber).padStart(4, "0")}-${slug}.md`;
-    const filePath = join6(outputDir, filename);
+    const filePath = join5(outputDir, filename);
     let content;
     switch (format) {
       case "madr":
@@ -24163,7 +24594,7 @@ var ADRExporter = class {
   // Export all decisions
   exportAllDecisions(decisions, options = {}) {
     const exportedFiles = [];
-    const outputDir = options.outputDir || join6(this.projectPath, "docs", "decisions");
+    const outputDir = options.outputDir || join5(this.projectPath, "docs", "decisions");
     const sorted = [...decisions].sort(
       (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
     );
@@ -24179,7 +24610,7 @@ var ADRExporter = class {
   }
   // Generate index file
   generateIndex(decisions, outputDir) {
-    const indexPath = join6(outputDir, "README.md");
+    const indexPath = join5(outputDir, "README.md");
     const lines = [
       "# Architecture Decision Records",
       "",
@@ -24331,7 +24762,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 { dirname as dirname5, join as join7, basename as basename3 } from "path";
+import { dirname as dirname4, join as join6, basename as basename3 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var MAX_FILES = 20;
 var MAX_CHANGES = 50;
@@ -24351,7 +24782,7 @@ var FeatureContextManager = class extends EventEmitter3 {
     super();
     this.projectPath = projectPath;
     this.dataDir = dataDir;
-    this.persistPath = join7(dataDir, "feature-context.json");
+    this.persistPath = join6(dataDir, "feature-context.json");
     this.load();
     this.startInactivityTimer();
   }
@@ -24580,7 +25011,7 @@ var FeatureContextManager = class extends EventEmitter3 {
   // ========== PERSISTENCE ==========
   save() {
     try {
-      const dir = dirname5(this.persistPath);
+      const dir = dirname4(this.persistPath);
       if (!existsSync6(dir)) {
         mkdirSync5(dir, { recursive: true });
       }
@@ -24643,7 +25074,7 @@ var FeatureContextManager = class extends EventEmitter3 {
     if (relativePath.startsWith(this.projectPath)) {
       return relativePath;
     }
-    return join7(this.projectPath, relativePath);
+    return join6(this.projectPath, relativePath);
   }
   // ========== CONTEXT RESURRECTION ==========
   /**
@@ -24842,7 +25273,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 { basename as basename4, join as join8 } from "path";
+import { basename as basename4, join as join7 } from "path";
 var ArchitectureGenerator = class _ArchitectureGenerator {
   projectPath;
   tier2;
@@ -24920,7 +25351,7 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
   detectLayers() {
     const layers = [];
     const layerMap = /* @__PURE__ */ new Map();
-    const srcDir = existsSync7(join8(this.projectPath, "src")) ? join8(this.projectPath, "src") : this.projectPath;
+    const srcDir = existsSync7(join7(this.projectPath, "src")) ? join7(this.projectPath, "src") : this.projectPath;
     try {
       const entries = readdirSync2(srcDir, { withFileTypes: true });
       for (const entry of entries) {
@@ -24928,7 +25359,7 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
         const dirName = entry.name.toLowerCase();
         const layerName = _ArchitectureGenerator.LAYER_MAPPING[dirName];
         if (layerName) {
-          const dirPath = join8(srcDir, entry.name);
+          const dirPath = join7(srcDir, entry.name);
           const relativePath = dirPath.replace(this.projectPath, "").replace(/^[/\\]/, "");
           const files = this.getFilesInDirectory(relativePath);
           if (files.length > 0) {
@@ -24971,12 +25402,12 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
   }
   getFilesInDirectory(relativePath) {
     const files = [];
-    const absolutePath = join8(this.projectPath, relativePath);
+    const absolutePath = join7(this.projectPath, relativePath);
     try {
       const entries = readdirSync2(absolutePath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && this.isCodeFile(entry.name)) {
-          files.push(join8(relativePath, entry.name));
+          files.push(join7(relativePath, entry.name));
         }
       }
     } catch {
@@ -25105,7 +25536,7 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
   }
   getProjectDependencies() {
     const deps = [];
-    const packageJsonPath = join8(this.projectPath, "package.json");
+    const packageJsonPath = join7(this.projectPath, "package.json");
     if (existsSync7(packageJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
@@ -25133,7 +25564,7 @@ var ArchitectureGenerator = class _ArchitectureGenerator {
       } catch {
       }
     }
-    const requirementsPath = join8(this.projectPath, "requirements.txt");
+    const requirementsPath = join7(this.projectPath, "requirements.txt");
     if (existsSync7(requirementsPath)) {
       try {
         const content = readFileSync7(requirementsPath, "utf-8");
@@ -25178,7 +25609,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 { basename as basename5, extname as extname2, join as join9 } from "path";
+import { basename as basename5, extname as extname2, join as join8 } from "path";
 var ComponentGenerator = class {
   projectPath;
   tier2;
@@ -25186,7 +25617,7 @@ var ComponentGenerator = class {
   constructor(projectPath, tier2) {
     this.projectPath = projectPath;
     this.tier2 = tier2;
-    this.isGitRepo = existsSync8(join9(projectPath, ".git"));
+    this.isGitRepo = existsSync8(join8(projectPath, ".git"));
   }
   async generate(filePath) {
     const file2 = this.tier2.getFile(filePath);
@@ -25355,7 +25786,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 { join as join10 } from "path";
+import { join as join9 } from "path";
 var ChangelogGenerator = class {
   projectPath;
   db;
@@ -25363,7 +25794,7 @@ var ChangelogGenerator = class {
   constructor(projectPath, db) {
     this.projectPath = projectPath;
     this.db = db;
-    this.isGitRepo = existsSync9(join10(projectPath, ".git"));
+    this.isGitRepo = existsSync9(join9(projectPath, ".git"));
   }
   async generate(options = {}) {
     if (!this.isGitRepo) {
@@ -25810,7 +26241,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 { join as join11 } from "path";
+import { join as join10 } from "path";
 var ActivityTracker = class {
   projectPath;
   db;
@@ -25820,7 +26251,7 @@ var ActivityTracker = class {
     this.projectPath = projectPath;
     this.db = db;
     this.tier2 = tier2;
-    this.isGitRepo = existsSync10(join11(projectPath, ".git"));
+    this.isGitRepo = existsSync10(join10(projectPath, ".git"));
   }
   async whatHappened(since, scope) {
     const sinceDate = this.parseSinceString(since);
@@ -30036,7 +30467,7 @@ ${category.toUpperCase()}:`);
 
 // src/core/test-awareness/test-indexer.ts
 import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 
 // src/core/test-awareness/test-parser.ts
 import { createHash as createHash4 } from "crypto";
@@ -30598,7 +31029,7 @@ var TestIndexer = class {
     this.parser = new TestParser();
   }
   detectFramework() {
-    const packageJsonPath = join12(this.projectPath, "package.json");
+    const packageJsonPath = join11(this.projectPath, "package.json");
     if (existsSync11(packageJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
@@ -30611,21 +31042,21 @@ var TestIndexer = class {
     }
     const pytestConfigs = ["pytest.ini", "pyproject.toml", "setup.cfg", "conftest.py"];
     for (const config2 of pytestConfigs) {
-      if (existsSync11(join12(this.projectPath, config2))) {
-        const content = readFileSync8(join12(this.projectPath, config2), "utf-8");
+      if (existsSync11(join11(this.projectPath, config2))) {
+        const content = readFileSync8(join11(this.projectPath, config2), "utf-8");
         if (content.includes("[pytest]") || content.includes("pytest") || config2 === "conftest.py") {
           return "pytest";
         }
       }
     }
-    const goMod = join12(this.projectPath, "go.mod");
+    const goMod = join11(this.projectPath, "go.mod");
     if (existsSync11(goMod)) {
       return "go";
     }
     const vitestConfigs = ["vitest.config.ts", "vitest.config.js", "vite.config.ts", "vite.config.js"];
     for (const config2 of vitestConfigs) {
-      if (existsSync11(join12(this.projectPath, config2))) {
-        const content = readFileSync8(join12(this.projectPath, config2), "utf-8");
+      if (existsSync11(join11(this.projectPath, config2))) {
+        const content = readFileSync8(join11(this.projectPath, config2), "utf-8");
         if (content.includes("vitest") || content.includes("test:")) {
           return "vitest";
         }
@@ -30633,7 +31064,7 @@ var TestIndexer = class {
     }
     const jestConfigs = ["jest.config.ts", "jest.config.js", "jest.config.json"];
     for (const config2 of jestConfigs) {
-      if (existsSync11(join12(this.projectPath, config2))) {
+      if (existsSync11(join11(this.projectPath, config2))) {
         return "jest";
       }
     }
@@ -30672,7 +31103,7 @@ var TestIndexer = class {
           absolute: false
         });
         for (const file2 of files) {
-          const absolutePath = join12(this.projectPath, file2);
+          const absolutePath = join11(this.projectPath, file2);
           const tests = this.parseTestFile(absolutePath, file2);
           allTests.push(...tests);
         }
@@ -30799,7 +31230,7 @@ var TestIndexer = class {
           absolute: false
         });
         for (const file2 of files) {
-          const absolutePath = join12(this.projectPath, file2);
+          const absolutePath = join11(this.projectPath, file2);
           const tests = this.parseTestFile(absolutePath, file2);
           allTests.push(...tests);
         }
@@ -31833,6 +32264,8 @@ var TECH_PATTERNS = [
 var GhostMode = class {
   activeFiles = /* @__PURE__ */ new Map();
   recentDecisions = /* @__PURE__ */ new Map();
+  recentImpacts = /* @__PURE__ */ new Map();
+  // Track file impacts
   tier2;
   embeddingGenerator;
   // Ghost mode settings
@@ -31840,10 +32273,47 @@ var GhostMode = class {
   FILE_TTL_MS = 60 * 60 * 1e3;
   // 1 hour
   DECISION_CACHE_SIZE = 50;
+  IMPACT_TTL_MS = 30 * 60 * 1e3;
+  // 30 minutes
   constructor(tier2, embeddingGenerator) {
     this.tier2 = tier2;
     this.embeddingGenerator = embeddingGenerator;
   }
+  /**
+   * Called when a file change impacts other files
+   */
+  onFileImpact(changedFile, affectedFiles) {
+    const impact = {
+      changedFile,
+      affectedFiles,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    for (const file2 of affectedFiles) {
+      this.recentImpacts.set(file2, impact);
+    }
+    this.evictStaleImpacts();
+  }
+  /**
+   * Check if a file was recently impacted by changes to another file
+   */
+  getImpactWarning(filePath) {
+    const impact = this.recentImpacts.get(filePath);
+    if (!impact) return null;
+    const age = Date.now() - impact.timestamp.getTime();
+    if (age > this.IMPACT_TTL_MS) {
+      this.recentImpacts.delete(filePath);
+      return null;
+    }
+    return impact;
+  }
+  evictStaleImpacts() {
+    const now = Date.now();
+    for (const [file2, impact] of this.recentImpacts) {
+      if (now - impact.timestamp.getTime() > this.IMPACT_TTL_MS) {
+        this.recentImpacts.delete(file2);
+      }
+    }
+  }
   /**
    * Called when any file is read - silently track and pre-fetch decisions
    */
@@ -32399,7 +32869,7 @@ var DejaVuDetector = class {
 
 // src/core/code-verifier.ts
 import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join13, dirname as dirname7, extname as extname4 } from "path";
+import { join as join12, dirname as dirname6, extname as extname4 } from "path";
 var SECURITY_PATTERNS2 = [
   // SQL Injection
   {
@@ -32644,11 +33114,11 @@ var CodeVerifier = class {
   nodeModulesPath;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.nodeModulesPath = join13(projectPath, "node_modules");
+    this.nodeModulesPath = join12(projectPath, "node_modules");
     this.loadPackageJson();
   }
   loadPackageJson() {
-    const packageJsonPath = join13(this.projectPath, "package.json");
+    const packageJsonPath = join12(this.projectPath, "package.json");
     if (existsSync12(packageJsonPath)) {
       try {
         this.packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
@@ -32801,7 +33271,7 @@ var CodeVerifier = class {
       }
       const packageName = this.getPackageName(importPath);
       if (!packages.has(packageName)) {
-        const nodeModulePath = join13(this.nodeModulesPath, packageName);
+        const nodeModulePath = join12(this.nodeModulesPath, packageName);
         if (existsSync12(nodeModulePath)) {
           issues.push({
             package: packageName,
@@ -32844,22 +33314,22 @@ var CodeVerifier = class {
   }
   verifyRelativeImport(importPath, file2, issues) {
     if (!file2) return;
-    const baseDir = dirname7(join13(this.projectPath, file2));
+    const baseDir = dirname6(join12(this.projectPath, file2));
     const possibleExtensions = [".ts", ".tsx", ".js", ".jsx", ".json", ""];
     const possibleIndexes = ["index.ts", "index.tsx", "index.js", "index.jsx"];
     let found = false;
     for (const ext of possibleExtensions) {
-      const fullPath = join13(baseDir, importPath + ext);
+      const fullPath = join12(baseDir, importPath + ext);
       if (existsSync12(fullPath)) {
         found = true;
         break;
       }
     }
     if (!found) {
-      const dirPath = join13(baseDir, importPath);
+      const dirPath = join12(baseDir, importPath);
       if (existsSync12(dirPath)) {
         for (const indexFile of possibleIndexes) {
-          if (existsSync12(join13(dirPath, indexFile))) {
+          if (existsSync12(join12(dirPath, indexFile))) {
             found = true;
             break;
           }
@@ -32877,7 +33347,7 @@ var CodeVerifier = class {
   }
   verifyPackageImport(importPath, issues, warnings) {
     const packageName = this.getPackageName(importPath);
-    const nodeModulePath = join13(this.nodeModulesPath, packageName);
+    const nodeModulePath = join12(this.nodeModulesPath, packageName);
     if (!existsSync12(nodeModulePath)) {
       issues.push({
         import: importPath,
@@ -32889,7 +33359,7 @@ var CodeVerifier = class {
     }
     if (importPath !== packageName) {
       const subpath = importPath.slice(packageName.length + 1);
-      const subpathFull = join13(nodeModulePath, subpath);
+      const subpathFull = join12(nodeModulePath, subpath);
       const possibleExtensions = [".js", ".json", ""];
       let found = false;
       for (const ext of possibleExtensions) {
@@ -32898,7 +33368,7 @@ var CodeVerifier = class {
           break;
         }
       }
-      const pkgJsonPath = join13(nodeModulePath, "package.json");
+      const pkgJsonPath = join12(nodeModulePath, "package.json");
       if (!found && existsSync12(pkgJsonPath)) {
         try {
           const pkgJson = JSON.parse(readFileSync9(pkgJsonPath, "utf-8"));
@@ -33323,7 +33793,17 @@ var MemoryLayerEngine = class {
     if (!existsSync13(config2.dataDir)) {
       mkdirSync6(config2.dataDir, { recursive: true });
     }
-    const dbPath = join14(config2.dataDir, "memorylayer.db");
+    let dbPath = join13(config2.dataDir, "neuronlayer.db");
+    const oldDbPath = join13(config2.dataDir, "memorylayer.db");
+    if (!existsSync13(dbPath) && existsSync13(oldDbPath)) {
+      try {
+        console.error("Migrating database from memorylayer.db to neuronlayer.db...");
+        renameSync(oldDbPath, dbPath);
+      } catch (err) {
+        console.error("Migration skipped (file in use), using existing database");
+        dbPath = oldDbPath;
+      }
+    }
     this.db = initializeDatabase(dbPath);
     this.tier1 = new Tier1Storage(config2.dataDir);
     this.tier2 = new Tier2Storage(this.db);
@@ -33418,11 +33898,31 @@ var MemoryLayerEngine = class {
       this.updateProjectSummary();
       this.updateProjectStats();
       this.extractDecisions().catch((err) => console.error("Decision extraction error:", err));
+      try {
+        const testResult = this.testAwareness.refreshIndex();
+        if (testResult.testsIndexed > 0) {
+          console.error(`Test index: ${testResult.testsIndexed} tests (${testResult.framework})`);
+        }
+      } catch (err) {
+        console.error("Test indexing error:", err);
+      }
     });
     this.indexer.on("fileIndexed", (path) => {
       this.featureContextManager.onFileOpened(path);
       this.summarizer.invalidateSummaryByPath(path);
     });
+    this.indexer.on("fileImpact", (impact) => {
+      if (impact.affectedCount > 0) {
+        console.error(`[Impact] ${impact.file} changed \u2192 ${impact.affectedCount} file(s) may be affected`);
+        if (impact.affectedCount <= 5) {
+          impact.affectedFiles.forEach((f) => console.error(`  \u2192 ${f}`));
+        } else {
+          impact.affectedFiles.slice(0, 3).forEach((f) => console.error(`  \u2192 ${f}`));
+          console.error(`  ... and ${impact.affectedCount - 3} more`);
+        }
+        this.ghostMode.onFileImpact(impact.file, impact.affectedFiles);
+      }
+    });
     this.indexer.on("error", (error2) => {
       console.error("Indexer error:", error2);
     });
@@ -33629,7 +34129,7 @@ ${description}`,
   }
   async getFileContext(filePath) {
     this.activityGate.recordActivity();
-    const absolutePath = join14(this.config.projectPath, filePath);
+    const absolutePath = join13(this.config.projectPath, filePath);
     if (!existsSync13(absolutePath)) {
       return null;
     }
@@ -33716,7 +34216,7 @@ ${decision.description}`;
     const commonDirs = ["src", "lib", "app", "pages", "components", "api", "server", "client", "core"];
     const found = [];
     for (const dir of commonDirs) {
-      if (existsSync13(join14(this.config.projectPath, dir))) {
+      if (existsSync13(join13(this.config.projectPath, dir))) {
         found.push(dir);
       }
     }
@@ -33724,7 +34224,7 @@ ${decision.description}`;
   }
   detectDependencies() {
     const deps = [];
-    const packageJsonPath = join14(this.config.projectPath, "package.json");
+    const packageJsonPath = join13(this.config.projectPath, "package.json");
     if (existsSync13(packageJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
@@ -33736,7 +34236,7 @@ ${decision.description}`;
       } catch {
       }
     }
-    const requirementsPath = join14(this.config.projectPath, "requirements.txt");
+    const requirementsPath = join13(this.config.projectPath, "requirements.txt");
     if (existsSync13(requirementsPath)) {
       try {
         const content = readFileSync10(requirementsPath, "utf-8");
@@ -33779,6 +34279,14 @@ ${decision.description}`;
     }));
     return { imports, importedBy, symbols };
   }
+  // Find circular dependencies in the project
+  findCircularDependencies() {
+    return this.tier2.findCircularDependencies();
+  }
+  // Get transitive dependents (all files affected by changing a file)
+  getTransitiveDependents(filePath, maxDepth = 3) {
+    return this.tier2.getTransitiveDependents(filePath, maxDepth);
+  }
   // Phase 2: Get symbol count
   getSymbolCount() {
     return this.tier2.getSymbolCount();
@@ -33793,7 +34301,7 @@ ${decision.description}`;
     let fetched = 0;
     for (const filePath of predicted) {
       if (!this.learningEngine.isInHotCache(filePath)) {
-        const absolutePath = join14(this.config.projectPath, filePath);
+        const absolutePath = join13(this.config.projectPath, filePath);
         if (existsSync13(absolutePath)) {
           try {
             const content = readFileSync10(absolutePath, "utf-8");
@@ -36758,6 +37266,83 @@ async function handleToolCall(engine, toolName, args) {
         symbols: result.symbols
       };
     }
+    case "find_circular_deps": {
+      const cycles = engine.findCircularDependencies();
+      if (cycles.length === 0) {
+        return {
+          status: "clean",
+          message: "No circular dependencies found",
+          cycles: []
+        };
+      }
+      return {
+        status: "cycles_found",
+        message: `Found ${cycles.length} circular dependency chain(s)`,
+        cycles: cycles.map((cycle, i) => ({
+          id: i + 1,
+          files: cycle,
+          length: cycle.length - 1,
+          // -1 because last element repeats first
+          description: cycle.join(" \u2192 ")
+        })),
+        recommendation: "Break cycles by extracting shared code into a separate module, using dependency injection, or restructuring imports."
+      };
+    }
+    case "get_impact_analysis": {
+      const filePath = args.file;
+      const depth = args.depth || 3;
+      const includeTests = args.include_tests !== false;
+      const affected = engine.getTransitiveDependents(filePath, depth);
+      const deps = engine.getFileDependencies(filePath);
+      let affectedTests = [];
+      if (includeTests) {
+        const allAffectedFiles = [filePath, ...affected.map((a) => a.file)];
+        const testSet = /* @__PURE__ */ new Set();
+        for (const f of allAffectedFiles) {
+          const tests = engine.getTestsForFile(f);
+          for (const t of tests) {
+            if (!testSet.has(t.id)) {
+              testSet.add(t.id);
+              affectedTests.push({ name: t.name, file: t.file });
+            }
+          }
+        }
+      }
+      const allCycles = engine.findCircularDependencies();
+      const relevantCycles = allCycles.filter((cycle) => cycle.includes(filePath));
+      const totalAffected = affected.length;
+      const riskLevel = totalAffected > 10 ? "HIGH" : totalAffected > 5 ? "MEDIUM" : "LOW";
+      const riskFactors = [];
+      if (totalAffected > 10) riskFactors.push(`${totalAffected} files depend on this`);
+      if (relevantCycles.length > 0) riskFactors.push(`Involved in ${relevantCycles.length} circular dependency chain(s)`);
+      if (affectedTests.length > 5) riskFactors.push(`${affectedTests.length} tests may need updates`);
+      if (deps.imports.length > 10) riskFactors.push(`File has ${deps.imports.length} dependencies`);
+      return {
+        file: filePath,
+        risk_level: riskLevel,
+        risk_factors: riskFactors.length > 0 ? riskFactors : ["No significant risk factors detected"],
+        summary: {
+          total_affected_files: totalAffected,
+          direct_dependents: affected.filter((a) => a.depth === 1).length,
+          indirect_dependents: affected.filter((a) => a.depth > 1).length,
+          affected_tests: affectedTests.length,
+          circular_dependencies: relevantCycles.length
+        },
+        direct_dependents: affected.filter((a) => a.depth === 1).map((a) => ({
+          file: a.file,
+          imports: a.imports
+        })),
+        indirect_dependents: affected.filter((a) => a.depth > 1).map((a) => ({
+          file: a.file,
+          depth: a.depth,
+          imports: a.imports
+        })),
+        this_file_imports: deps.imports.map((i) => i.file),
+        affected_tests: affectedTests,
+        circular_dependencies: relevantCycles.map((cycle) => cycle.join(" \u2192 ")),
+        recommendation: riskLevel === "HIGH" ? "High-impact change. Consider breaking it into smaller changes and testing incrementally." : riskLevel === "MEDIUM" ? "Moderate impact. Review affected files and ensure tests cover the changes." : "Low-risk change. Standard review and testing should suffice."
+      };
+    }
     case "get_file_summary": {
       const path = args.path;
       const summary = engine.getFileSummary(path);
@@ -37918,7 +38503,7 @@ var MCPServer = class {
     this.engine = new MemoryLayerEngine(config2);
     this.server = new Server(
       {
-        name: "memorylayer",
+        name: "neuronlayer",
         version: "0.1.0"
       },
       {
@@ -38021,13 +38606,13 @@ var MCPServer = class {
 };
 
 // src/utils/config.ts
-import { join as join15, resolve as resolve2 } from "path";
+import { join as join14, resolve as resolve2 } from "path";
 function getDefaultConfig(projectPath) {
   const normalizedPath = resolve2(projectPath);
   return {
     projectPath: normalizedPath,
     // Store in project directory (standard practice like .git/, .vscode/)
-    dataDir: join15(normalizedPath, ".memorylayer"),
+    dataDir: join14(normalizedPath, ".memorylayer"),
     maxTokens: 6e3,
     embeddingModel: "Xenova/all-MiniLM-L6-v2",
     // Fallback model, faster and smaller
@@ -38189,7 +38774,7 @@ function parseArgs(args) {
 }
 
 // src/cli/commands.ts
-import { join as join16 } from "path";
+import { join as join15 } from "path";
 import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir2 } from "os";
 var projectManager = new ProjectManager();
@@ -38305,12 +38890,17 @@ function exportDecisions(projectPath, options = {}) {
       message: `Project not registered: ${targetPath}. Use "memorylayer projects add ${targetPath}" first.`
     };
   }
-  const dbPath = join16(projectInfo.dataDir, "memorylayer.db");
+  let dbPath = join15(projectInfo.dataDir, "neuronlayer.db");
   if (!existsSync14(dbPath)) {
-    return {
-      success: false,
-      message: `Project database not found. Has the project been indexed?`
-    };
+    const oldDbPath = join15(projectInfo.dataDir, "memorylayer.db");
+    if (existsSync14(oldDbPath)) {
+      dbPath = oldDbPath;
+    } else {
+      return {
+        success: false,
+        message: `Project database not found. Has the project been indexed?`
+      };
+    }
   }
   const db = initializeDatabase(dbPath);
   const tier2 = new Tier2Storage(db);
@@ -38330,7 +38920,7 @@ function exportDecisions(projectPath, options = {}) {
   });
   return {
     success: true,
-    message: `Exported ${exportedFiles.length} ADR files to ${options.outputDir || join16(targetPath, "docs", "decisions")}`,
+    message: `Exported ${exportedFiles.length} ADR files to ${options.outputDir || join15(targetPath, "docs", "decisions")}`,
     data: exportedFiles
   };
 }
@@ -38403,11 +38993,11 @@ function initProject(projectPath) {
   const failedClients = [];
   let claudeConfigPath;
   if (platform === "win32") {
-    claudeConfigPath = join16(homedir2(), "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+    claudeConfigPath = join15(homedir2(), "AppData", "Roaming", "Claude", "claude_desktop_config.json");
   } else if (platform === "darwin") {
-    claudeConfigPath = join16(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    claudeConfigPath = join15(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   } else {
-    claudeConfigPath = join16(homedir2(), ".config", "claude", "claude_desktop_config.json");
+    claudeConfigPath = join15(homedir2(), ".config", "claude", "claude_desktop_config.json");
   }
   const claudeResult = configureMCPClient("Claude Desktop", claudeConfigPath, serverName, targetPath);
   if (claudeResult.success) {
@@ -38415,14 +39005,14 @@ function initProject(projectPath) {
   } else {
     failedClients.push(claudeResult.message);
   }
-  const openCodeConfigPath = join16(homedir2(), ".opencode", "config.json");
+  const openCodeConfigPath = join15(homedir2(), ".opencode", "config.json");
   const openCodeResult = configureMCPClient("OpenCode", openCodeConfigPath, serverName, targetPath);
   if (openCodeResult.success) {
     configuredClients.push(openCodeResult.message);
   } else {
     failedClients.push(openCodeResult.message);
   }
-  const claudeCodeConfigPath = join16(homedir2(), ".claude.json");
+  const claudeCodeConfigPath = join15(homedir2(), ".claude.json");
   const claudeCodeResult = configureMCPClient("Claude Code", claudeCodeConfigPath, serverName, targetPath);
   if (claudeCodeResult.success) {
     configuredClients.push(claudeCodeResult.message);