@liendev/lien 0.16.0 → 0.18.0

package/dist/index.js

@@ -378,8 +378,8 @@ var init_errors = __esm({
 });
 
 // src/config/service.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 var ConfigService, configService;
 var init_service = __esm({
   "src/config/service.ts"() {
@@ -401,13 +401,13 @@ var init_service = __esm({
       async load(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs8.readFile(configPath, "utf-8");
+          const configContent = await fs9.readFile(configPath, "utf-8");
           const userConfig = JSON.parse(configContent);
           if (this.needsMigration(userConfig)) {
             console.log("\u{1F504} Migrating config from v0.2.0 to v0.3.0...");
             const result = await this.migrate(rootDir);
             if (result.migrated && result.backupPath) {
-              const backupFilename = path8.basename(result.backupPath);
+              const backupFilename = path9.basename(result.backupPath);
               console.log(`\u2705 Migration complete! Backup saved as ${backupFilename}`);
               console.log("\u{1F4DD} Your config now uses the framework-based structure.");
             }
@@ -463,7 +463,7 @@ ${validation.errors.join("\n")}`,
         }
         try {
           const configJson = JSON.stringify(config, null, 2) + "\n";
-          await fs8.writeFile(configPath, configJson, "utf-8");
+          await fs9.writeFile(configPath, configJson, "utf-8");
         } catch (error) {
           throw wrapError(error, "Failed to save configuration", { path: configPath });
         }
@@ -477,7 +477,7 @@ ${validation.errors.join("\n")}`,
       async exists(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          await fs8.access(configPath);
+          await fs9.access(configPath);
           return true;
         } catch {
           return false;
@@ -494,7 +494,7 @@ ${validation.errors.join("\n")}`,
       async migrate(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs8.readFile(configPath, "utf-8");
+          const configContent = await fs9.readFile(configPath, "utf-8");
           const oldConfig = JSON.parse(configContent);
           if (!this.needsMigration(oldConfig)) {
             return {
@@ -512,7 +512,7 @@ ${validation.errors.join("\n")}`,
             );
           }
           const backupPath = `${configPath}.v0.2.0.backup`;
-          await fs8.copyFile(configPath, backupPath);
+          await fs9.copyFile(configPath, backupPath);
           await this.save(rootDir, newConfig);
           return {
             migrated: true,
@@ -610,7 +610,7 @@ ${validation.errors.join("\n")}`,
        * Get the full path to the config file
        */
       getConfigPath(rootDir) {
-        return path8.join(rootDir, _ConfigService.CONFIG_FILENAME);
+        return path9.join(rootDir, _ConfigService.CONFIG_FILENAME);
       }
       /**
        * Validate modern (v0.3.0+) configuration
@@ -774,7 +774,7 @@ ${validation.errors.join("\n")}`,
             errors.push(`frameworks[${index}] missing required field: path`);
           } else if (typeof fw.path !== "string") {
             errors.push(`frameworks[${index}].path must be a string`);
-          } else if (path8.isAbsolute(fw.path)) {
+          } else if (path9.isAbsolute(fw.path)) {
             errors.push(`frameworks[${index}].path must be relative, got: ${fw.path}`);
           }
           if (fw.enabled === void 0) {
@@ -834,12 +834,12 @@ __export(utils_exports, {
 });
 import { exec } from "child_process";
 import { promisify } from "util";
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 async function isGitRepo(rootDir) {
   try {
-    const gitDir = path9.join(rootDir, ".git");
-    await fs9.access(gitDir);
+    const gitDir = path10.join(rootDir, ".git");
+    await fs10.access(gitDir);
     return true;
   } catch {
     return false;
@@ -878,7 +878,7 @@ async function getChangedFiles(rootDir, fromRef, toRef) {
         // 10 second timeout for diffs
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path9.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path10.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files: ${error}`);
@@ -893,7 +893,7 @@ async function getChangedFilesInCommit(rootDir, commitSha) {
         timeout: 1e4
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path9.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path10.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files in commit: ${error}`);
@@ -908,7 +908,7 @@ async function getChangedFilesBetweenCommits(rootDir, fromCommit, toCommit) {
         timeout: 1e4
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path9.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path10.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files between commits: ${error}`);
@@ -931,21 +931,21 @@ var init_utils = __esm({
 });
 
 // src/vectordb/version.ts
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 async function writeVersionFile(indexPath) {
   try {
-    const versionFilePath = path10.join(indexPath, VERSION_FILE);
+    const versionFilePath = path11.join(indexPath, VERSION_FILE);
     const timestamp = Date.now().toString();
-    await fs10.writeFile(versionFilePath, timestamp, "utf-8");
+    await fs11.writeFile(versionFilePath, timestamp, "utf-8");
   } catch (error) {
     console.error(`Warning: Failed to write version file: ${error}`);
   }
 }
 async function readVersionFile(indexPath) {
   try {
-    const versionFilePath = path10.join(indexPath, VERSION_FILE);
-    const content = await fs10.readFile(versionFilePath, "utf-8");
+    const versionFilePath = path11.join(indexPath, VERSION_FILE);
+    const content = await fs11.readFile(versionFilePath, "utf-8");
     const timestamp = parseInt(content.trim(), 10);
     return isNaN(timestamp) ? 0 : timestamp;
   } catch (error) {
@@ -963,8 +963,8 @@ var init_version2 = __esm({
 // src/indexer/scanner.ts
 import { glob } from "glob";
 import ignore from "ignore";
-import fs12 from "fs/promises";
-import path12 from "path";
+import fs13 from "fs/promises";
+import path13 from "path";
 async function scanCodebaseWithFrameworks(rootDir, config) {
   const allFiles = [];
   for (const framework of config.frameworks) {
@@ -977,16 +977,16 @@ async function scanCodebaseWithFrameworks(rootDir, config) {
   return allFiles;
 }
 async function scanFramework(rootDir, framework) {
-  const frameworkPath = path12.join(rootDir, framework.path);
-  const gitignorePath = path12.join(frameworkPath, ".gitignore");
+  const frameworkPath = path13.join(rootDir, framework.path);
+  const gitignorePath = path13.join(frameworkPath, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs12.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs13.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
-    const rootGitignorePath = path12.join(rootDir, ".gitignore");
+    const rootGitignorePath = path13.join(rootDir, ".gitignore");
     try {
-      const gitignoreContent = await fs12.readFile(rootGitignorePath, "utf-8");
+      const gitignoreContent = await fs13.readFile(rootGitignorePath, "utf-8");
       ig = ignore().add(gitignoreContent);
     } catch (e2) {
     }
@@ -1008,15 +1008,15 @@ async function scanFramework(rootDir, framework) {
   }
   const uniqueFiles = Array.from(new Set(allFiles));
   return uniqueFiles.filter((file) => !ig.ignores(file)).map((file) => {
-    return framework.path === "." ? file : path12.join(framework.path, file);
+    return framework.path === "." ? file : path13.join(framework.path, file);
   });
 }
 async function scanCodebase(options) {
   const { rootDir, includePatterns = [], excludePatterns = [] } = options;
-  const gitignorePath = path12.join(rootDir, ".gitignore");
+  const gitignorePath = path13.join(rootDir, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs12.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs13.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
   }
@@ -1043,12 +1043,12 @@ async function scanCodebase(options) {
   }
   const uniqueFiles = Array.from(new Set(allFiles));
   return uniqueFiles.filter((file) => {
-    const relativePath = path12.relative(rootDir, file);
+    const relativePath = path13.relative(rootDir, file);
     return !ig.ignores(relativePath);
   });
 }
 function detectLanguage(filepath) {
-  const ext = path12.extname(filepath).toLowerCase();
+  const ext = path13.extname(filepath).toLowerCase();
   const languageMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -2591,10 +2591,10 @@ var init_types2 = __esm({
 });
 
 // src/vectordb/boosting/strategies.ts
-import path13 from "path";
+import path14 from "path";
 function isDocumentationFile(filepath) {
   const lower = filepath.toLowerCase();
-  const filename = path13.basename(filepath).toLowerCase();
+  const filename = path14.basename(filepath).toLowerCase();
   if (filename.startsWith("readme")) return true;
   if (filename.startsWith("changelog")) return true;
   if (filename.endsWith(".md") || filename.endsWith(".mdx") || filename.endsWith(".markdown")) {
@@ -2651,7 +2651,7 @@ var init_strategies = __esm({
     FilenameBoostingStrategy = class {
       name = "filename-matching";
       apply(query, filepath, baseScore) {
-        const filename = path13.basename(filepath, path13.extname(filepath)).toLowerCase();
+        const filename = path14.basename(filepath, path14.extname(filepath)).toLowerCase();
         const queryTokens = query.toLowerCase().split(/\s+/);
         let boostFactor = 1;
         for (const token of queryTokens) {
@@ -3153,7 +3153,7 @@ __export(lancedb_exports, {
   VectorDB: () => VectorDB
 });
 import * as lancedb from "vectordb";
-import path14 from "path";
+import path15 from "path";
 import os2 from "os";
 import crypto2 from "crypto";
 var VectorDB;
@@ -3174,9 +3174,9 @@ var init_lancedb = __esm({
       lastVersionCheck = 0;
       currentVersion = 0;
       constructor(projectRoot) {
-        const projectName = path14.basename(projectRoot);
+        const projectName = path15.basename(projectRoot);
         const pathHash = crypto2.createHash("md5").update(projectRoot).digest("hex").substring(0, 8);
-        this.dbPath = path14.join(
+        this.dbPath = path15.join(
           os2.homedir(),
           ".lien",
           "indices",
@@ -3348,8 +3348,8 @@ var manifest_exports = {};
 __export(manifest_exports, {
   ManifestManager: () => ManifestManager
 });
-import fs13 from "fs/promises";
-import path15 from "path";
+import fs14 from "fs/promises";
+import path16 from "path";
 var MANIFEST_FILE, ManifestManager;
 var init_manifest = __esm({
   "src/indexer/manifest.ts"() {
@@ -3371,7 +3371,7 @@ var init_manifest = __esm({
        */
       constructor(indexPath) {
         this.indexPath = indexPath;
-        this.manifestPath = path15.join(indexPath, MANIFEST_FILE);
+        this.manifestPath = path16.join(indexPath, MANIFEST_FILE);
       }
       /**
        * Loads the manifest from disk.
@@ -3384,7 +3384,7 @@ var init_manifest = __esm({
        */
       async load() {
         try {
-          const content = await fs13.readFile(this.manifestPath, "utf-8");
+          const content = await fs14.readFile(this.manifestPath, "utf-8");
           const manifest = JSON.parse(content);
           if (manifest.formatVersion !== INDEX_FORMAT_VERSION) {
             console.error(
@@ -3411,7 +3411,7 @@ var init_manifest = __esm({
        */
       async save(manifest) {
         try {
-          await fs13.mkdir(this.indexPath, { recursive: true });
+          await fs14.mkdir(this.indexPath, { recursive: true });
           const manifestToSave = {
             ...manifest,
             formatVersion: INDEX_FORMAT_VERSION,
@@ -3419,7 +3419,7 @@ var init_manifest = __esm({
             lastIndexed: Date.now()
           };
           const content = JSON.stringify(manifestToSave, null, 2);
-          await fs13.writeFile(this.manifestPath, content, "utf-8");
+          await fs14.writeFile(this.manifestPath, content, "utf-8");
         } catch (error) {
           console.error(`[Lien] Warning: Failed to save manifest: ${error}`);
         }
@@ -3556,7 +3556,7 @@ var init_manifest = __esm({
        */
       async clear() {
         try {
-          await fs13.unlink(this.manifestPath);
+          await fs14.unlink(this.manifestPath);
         } catch (error) {
           if (error.code !== "ENOENT") {
             console.error(`[Lien] Warning: Failed to clear manifest: ${error}`);
@@ -3585,8 +3585,8 @@ var tracker_exports = {};
 __export(tracker_exports, {
   GitStateTracker: () => GitStateTracker
 });
-import fs14 from "fs/promises";
-import path16 from "path";
+import fs15 from "fs/promises";
+import path17 from "path";
 var GitStateTracker;
 var init_tracker = __esm({
   "src/git/tracker.ts"() {
@@ -3598,7 +3598,7 @@ var init_tracker = __esm({
       currentState = null;
       constructor(rootDir, indexPath) {
         this.rootDir = rootDir;
-        this.stateFile = path16.join(indexPath, ".git-state.json");
+        this.stateFile = path17.join(indexPath, ".git-state.json");
       }
       /**
        * Loads the last known git state from disk.
@@ -3606,7 +3606,7 @@ var init_tracker = __esm({
        */
       async loadState() {
         try {
-          const content = await fs14.readFile(this.stateFile, "utf-8");
+          const content = await fs15.readFile(this.stateFile, "utf-8");
           return JSON.parse(content);
         } catch {
           return null;
@@ -3618,7 +3618,7 @@ var init_tracker = __esm({
       async saveState(state) {
         try {
           const content = JSON.stringify(state, null, 2);
-          await fs14.writeFile(this.stateFile, content, "utf-8");
+          await fs15.writeFile(this.stateFile, content, "utf-8");
         } catch (error) {
           console.error(`[Lien] Warning: Failed to save git state: ${error}`);
         }
@@ -3769,7 +3769,7 @@ var init_tracker = __esm({
 });
 
 // src/indexer/change-detector.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 async function detectChanges(rootDir, vectorDB, config) {
   const manifest = new ManifestManager(vectorDB.dbPath);
   const savedManifest = await manifest.load();
@@ -3873,7 +3873,7 @@ async function mtimeBasedDetection(rootDir, savedManifest, config) {
   const fileStats = /* @__PURE__ */ new Map();
   for (const filepath of currentFiles) {
     try {
-      const stats = await fs15.stat(filepath);
+      const stats = await fs16.stat(filepath);
       fileStats.set(filepath, stats.mtimeMs);
     } catch {
       continue;
@@ -3927,7 +3927,7 @@ var init_result = __esm({
 });
 
 // src/indexer/incremental.ts
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 async function processFileContent(filepath, content, embeddings, config, verbose) {
   const chunkSize = isModernConfig(config) ? config.core.chunkSize : isLegacyConfig(config) ? config.indexing.chunkSize : 75;
   const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : isLegacyConfig(config) ? config.indexing.chunkOverlap : 10;
@@ -3966,7 +3966,7 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
   const { verbose } = options;
   try {
     try {
-      await fs16.access(filepath);
+      await fs17.access(filepath);
     } catch {
       if (verbose) {
         console.error(`[Lien] File deleted: ${filepath}`);
@@ -3976,9 +3976,9 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
       await manifest2.removeFile(filepath);
       return;
     }
-    const content = await fs16.readFile(filepath, "utf-8");
+    const content = await fs17.readFile(filepath, "utf-8");
     const result = await processFileContent(filepath, content, embeddings, config, verbose || false);
-    const stats = await fs16.stat(filepath);
+    const stats = await fs17.stat(filepath);
     const manifest = new ManifestManager(vectorDB.dbPath);
     if (result === null) {
       await vectorDB.deleteByFile(filepath);
@@ -4009,8 +4009,8 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
 }
 async function processSingleFileForIndexing(filepath, embeddings, config, verbose) {
   try {
-    const stats = await fs16.stat(filepath);
-    const content = await fs16.readFile(filepath, "utf-8");
+    const stats = await fs17.stat(filepath);
+    const content = await fs17.readFile(filepath, "utf-8");
     const result = await processFileContent(filepath, content, embeddings, config, verbose);
     return Ok({
       filepath,
@@ -4281,7 +4281,7 @@ var indexer_exports = {};
 __export(indexer_exports, {
   indexCodebase: () => indexCodebase
 });
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import ora from "ora";
 import chalk5 from "chalk";
 import pLimit from "p-limit";
@@ -4454,8 +4454,8 @@ async function performFullIndex(rootDir, vectorDB, config, options, spinner) {
     const filePromises = files.map(
       (file) => limit(async () => {
         try {
-          const stats = await fs17.stat(file);
-          const content = await fs17.readFile(file, "utf-8");
+          const stats = await fs18.stat(file);
+          const content = await fs18.readFile(file, "utf-8");
           const chunkSize = isModernConfig(config) ? config.core.chunkSize : 75;
           const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : 10;
           const useAST = isModernConfig(config) ? config.chunking.useAST : true;
@@ -4583,8 +4583,8 @@ import { dirname as dirname4, join as join4 } from "path";
 
 // src/cli/init.ts
 init_schema();
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import chalk3 from "chalk";
 import inquirer from "inquirer";
@@ -4751,8 +4751,8 @@ var MigrationManager = class {
 };
 
 // src/frameworks/detector-service.ts
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 
 // src/frameworks/types.ts
 var defaultDetectionOptions = {
@@ -4884,10 +4884,132 @@ var nodejsDetector = {
   }
 };
 
-// src/frameworks/laravel/detector.ts
+// src/frameworks/php/detector.ts
 import fs4 from "fs/promises";
 import path4 from "path";
 
+// src/frameworks/php/config.ts
+async function generatePhpConfig(_rootDir, _relativePath) {
+  return {
+    include: [
+      // PHP source code
+      "src/**/*.php",
+      "lib/**/*.php",
+      "app/**/*.php",
+      "tests/**/*.php",
+      "*.php",
+      // Common PHP project files
+      "config/**/*.php",
+      "public/**/*.php",
+      // Documentation
+      "**/*.md",
+      "**/*.mdx",
+      "docs/**/*.md",
+      "README.md",
+      "CHANGELOG.md"
+    ],
+    exclude: [
+      "vendor/**",
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      "storage/**",
+      "cache/**",
+      // Test artifacts
+      "coverage/**",
+      "test-results/**",
+      ".phpunit.cache/**",
+      // Build outputs
+      "__generated__/**"
+    ]
+  };
+}
+
+// src/frameworks/php/detector.ts
+var phpDetector = {
+  name: "php",
+  priority: 50,
+  // Generic, yields to specific frameworks like Laravel
+  async detect(rootDir, relativePath) {
+    const fullPath = path4.join(rootDir, relativePath);
+    const result = {
+      detected: false,
+      name: "php",
+      path: relativePath,
+      confidence: "low",
+      evidence: []
+    };
+    const composerJsonPath = path4.join(fullPath, "composer.json");
+    let composerJson = null;
+    try {
+      const content = await fs4.readFile(composerJsonPath, "utf-8");
+      composerJson = JSON.parse(content);
+      result.evidence.push("Found composer.json");
+    } catch {
+      return result;
+    }
+    const hasLaravel = composerJson.require?.["laravel/framework"] || composerJson["require-dev"]?.["laravel/framework"];
+    if (hasLaravel) {
+      return result;
+    }
+    result.detected = true;
+    result.confidence = "high";
+    const phpDirs = ["src", "lib", "app", "tests"];
+    let foundDirs = 0;
+    for (const dir of phpDirs) {
+      try {
+        const dirPath = path4.join(fullPath, dir);
+        const stats = await fs4.stat(dirPath);
+        if (stats.isDirectory()) {
+          foundDirs++;
+        }
+      } catch {
+      }
+    }
+    if (foundDirs > 0) {
+      result.evidence.push(`Found PHP project structure (${foundDirs} directories)`);
+    }
+    if (composerJson.require?.php) {
+      result.version = composerJson.require.php;
+      result.evidence.push(`PHP ${composerJson.require.php}`);
+    }
+    const testFrameworks = [
+      { name: "phpunit/phpunit", display: "PHPUnit" },
+      { name: "pestphp/pest", display: "Pest" },
+      { name: "codeception/codeception", display: "Codeception" },
+      { name: "behat/behat", display: "Behat" }
+    ];
+    for (const framework of testFrameworks) {
+      if (composerJson.require?.[framework.name] || composerJson["require-dev"]?.[framework.name]) {
+        result.evidence.push(`${framework.display} test framework detected`);
+        break;
+      }
+    }
+    const tools2 = [
+      { name: "symfony/framework-bundle", display: "Symfony" },
+      { name: "symfony/http-kernel", display: "Symfony" },
+      { name: "symfony/symfony", display: "Symfony (monolithic)" },
+      { name: "doctrine/orm", display: "Doctrine ORM" },
+      { name: "guzzlehttp/guzzle", display: "Guzzle HTTP" },
+      { name: "monolog/monolog", display: "Monolog" }
+    ];
+    for (const tool of tools2) {
+      if (composerJson.require?.[tool.name]) {
+        result.evidence.push(`${tool.display} detected`);
+        break;
+      }
+    }
+    return result;
+  },
+  async generateConfig(rootDir, relativePath) {
+    return generatePhpConfig(rootDir, relativePath);
+  }
+};
+
+// src/frameworks/laravel/detector.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+
 // src/frameworks/laravel/config.ts
 async function generateLaravelConfig(_rootDir, _relativePath) {
   return {
@@ -4943,7 +5065,7 @@ var laravelDetector = {
   priority: 100,
   // Laravel takes precedence over Node.js
   async detect(rootDir, relativePath) {
-    const fullPath = path4.join(rootDir, relativePath);
+    const fullPath = path5.join(rootDir, relativePath);
     const result = {
       detected: false,
       name: "laravel",
@@ -4951,10 +5073,10 @@ var laravelDetector = {
       confidence: "low",
       evidence: []
     };
-    const composerJsonPath = path4.join(fullPath, "composer.json");
+    const composerJsonPath = path5.join(fullPath, "composer.json");
     let composerJson = null;
     try {
-      const content = await fs4.readFile(composerJsonPath, "utf-8");
+      const content = await fs5.readFile(composerJsonPath, "utf-8");
       composerJson = JSON.parse(content);
       result.evidence.push("Found composer.json");
     } catch {
@@ -4965,9 +5087,9 @@ var laravelDetector = {
       return result;
     }
     result.evidence.push("Laravel framework detected in composer.json");
-    const artisanPath = path4.join(fullPath, "artisan");
+    const artisanPath = path5.join(fullPath, "artisan");
     try {
-      await fs4.access(artisanPath);
+      await fs5.access(artisanPath);
       result.evidence.push("Found artisan file");
       result.confidence = "high";
     } catch {
@@ -4977,8 +5099,8 @@ var laravelDetector = {
     let foundDirs = 0;
     for (const dir of laravelDirs) {
       try {
-        const dirPath = path4.join(fullPath, dir);
-        const stats = await fs4.stat(dirPath);
+        const dirPath = path5.join(fullPath, dir);
+        const stats = await fs5.stat(dirPath);
         if (stats.isDirectory()) {
           foundDirs++;
         }
@@ -4990,14 +5112,14 @@ var laravelDetector = {
       result.confidence = "high";
     }
     const testDirsToCheck = [
-      path4.join(fullPath, "tests", "Feature"),
-      path4.join(fullPath, "tests", "Unit")
+      path5.join(fullPath, "tests", "Feature"),
+      path5.join(fullPath, "tests", "Unit")
     ];
     for (const testDir of testDirsToCheck) {
       try {
-        const stats = await fs4.stat(testDir);
+        const stats = await fs5.stat(testDir);
         if (stats.isDirectory()) {
-          const dirName = path4.basename(path4.dirname(testDir)) + "/" + path4.basename(testDir);
+          const dirName = path5.basename(path5.dirname(testDir)) + "/" + path5.basename(testDir);
           result.evidence.push(`Found ${dirName} test directory`);
         }
       } catch {
@@ -5015,8 +5137,8 @@ var laravelDetector = {
 };
 
 // src/frameworks/shopify/detector.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 
 // src/frameworks/shopify/config.ts
 async function generateShopifyConfig(_rootDir, _relativePath) {
@@ -5074,7 +5196,7 @@ var shopifyDetector = {
   priority: 100,
   // High priority (same as Laravel)
   async detect(rootDir, relativePath) {
-    const fullPath = path5.join(rootDir, relativePath);
+    const fullPath = path6.join(rootDir, relativePath);
     const result = {
       detected: false,
       name: "shopify",
@@ -5082,18 +5204,18 @@ var shopifyDetector = {
       confidence: "low",
       evidence: []
     };
-    const settingsSchemaPath = path5.join(fullPath, "config", "settings_schema.json");
+    const settingsSchemaPath = path6.join(fullPath, "config", "settings_schema.json");
     let hasSettingsSchema = false;
     try {
-      await fs5.access(settingsSchemaPath);
+      await fs6.access(settingsSchemaPath);
       hasSettingsSchema = true;
       result.evidence.push("Found config/settings_schema.json");
     } catch {
     }
-    const themeLayoutPath = path5.join(fullPath, "layout", "theme.liquid");
+    const themeLayoutPath = path6.join(fullPath, "layout", "theme.liquid");
     let hasThemeLayout = false;
     try {
-      await fs5.access(themeLayoutPath);
+      await fs6.access(themeLayoutPath);
       hasThemeLayout = true;
       result.evidence.push("Found layout/theme.liquid");
     } catch {
@@ -5102,8 +5224,8 @@ var shopifyDetector = {
     let foundDirs = 0;
     for (const dir of shopifyDirs) {
       try {
-        const dirPath = path5.join(fullPath, dir);
-        const stats = await fs5.stat(dirPath);
+        const dirPath = path6.join(fullPath, dir);
+        const stats = await fs6.stat(dirPath);
         if (stats.isDirectory()) {
           foundDirs++;
         }
@@ -5114,14 +5236,14 @@ var shopifyDetector = {
       result.evidence.push(`Shopify directory structure detected (${foundDirs}/${shopifyDirs.length} dirs)`);
     }
     try {
-      const tomlPath = path5.join(fullPath, "shopify.theme.toml");
-      await fs5.access(tomlPath);
+      const tomlPath = path6.join(fullPath, "shopify.theme.toml");
+      await fs6.access(tomlPath);
       result.evidence.push("Found shopify.theme.toml");
     } catch {
     }
     try {
-      const ignorePath = path5.join(fullPath, ".shopifyignore");
-      await fs5.access(ignorePath);
+      const ignorePath = path6.join(fullPath, ".shopifyignore");
+      await fs6.access(ignorePath);
       result.evidence.push("Found .shopifyignore");
     } catch {
     }
@@ -5150,6 +5272,7 @@ var shopifyDetector = {
 // src/frameworks/registry.ts
 var frameworkDetectors = [
   nodejsDetector,
+  phpDetector,
   laravelDetector,
   shopifyDetector
 ];
@@ -5167,7 +5290,7 @@ async function detectAllFrameworks(rootDir, options = {}) {
   return results;
 }
 async function detectAtPath(rootDir, relativePath, results, visited) {
-  const fullPath = path6.join(rootDir, relativePath);
+  const fullPath = path7.join(rootDir, relativePath);
   if (visited.has(fullPath)) {
     return;
   }
@@ -5234,9 +5357,9 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
   if (depth >= options.maxDepth) {
     return;
   }
-  const fullPath = path6.join(rootDir, relativePath);
+  const fullPath = path7.join(rootDir, relativePath);
   try {
-    const entries = await fs6.readdir(fullPath, { withFileTypes: true });
+    const entries = await fs7.readdir(fullPath, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory());
     for (const dir of dirs) {
       if (options.skipDirs.includes(dir.name)) {
@@ -5245,7 +5368,7 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
       if (dir.name.startsWith(".")) {
         continue;
       }
-      const subPath = relativePath === "." ? dir.name : path6.join(relativePath, dir.name);
+      const subPath = relativePath === "." ? dir.name : path7.join(relativePath, dir.name);
       await detectAtPath(rootDir, subPath, results, visited);
       await scanSubdirectories(rootDir, subPath, results, visited, depth + 1, options);
     }
@@ -5256,14 +5379,14 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
 
 // src/cli/init.ts
 var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = path7.dirname(__filename3);
+var __dirname3 = path8.dirname(__filename3);
 async function initCommand(options = {}) {
   const rootDir = options.path || process.cwd();
-  const configPath = path7.join(rootDir, ".lien.config.json");
+  const configPath = path8.join(rootDir, ".lien.config.json");
   try {
     let configExists = false;
     try {
-      await fs7.access(configPath);
+      await fs8.access(configPath);
       configExists = true;
     } catch {
     }
@@ -5400,22 +5523,22 @@ async function createNewConfig(rootDir, options) {
     ]);
     if (installCursorRules) {
       try {
-        const cursorRulesDir = path7.join(rootDir, ".cursor");
-        await fs7.mkdir(cursorRulesDir, { recursive: true });
-        const templatePath = path7.join(__dirname3, "../CURSOR_RULES_TEMPLATE.md");
-        const rulesPath = path7.join(cursorRulesDir, "rules");
+        const cursorRulesDir = path8.join(rootDir, ".cursor");
+        await fs8.mkdir(cursorRulesDir, { recursive: true });
+        const templatePath = path8.join(__dirname3, "../CURSOR_RULES_TEMPLATE.md");
+        const rulesPath = path8.join(cursorRulesDir, "rules");
         let targetPath;
         let isDirectory = false;
         let isFile = false;
         try {
-          const stats = await fs7.stat(rulesPath);
+          const stats = await fs8.stat(rulesPath);
           isDirectory = stats.isDirectory();
           isFile = stats.isFile();
         } catch {
         }
         if (isDirectory) {
-          targetPath = path7.join(rulesPath, "lien.mdc");
-          await fs7.copyFile(templatePath, targetPath);
+          targetPath = path8.join(rulesPath, "lien.mdc");
+          await fs8.copyFile(templatePath, targetPath);
           console.log(chalk3.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         } else if (isFile) {
           const { convertToDir } = await inquirer.prompt([
@@ -5427,11 +5550,11 @@ async function createNewConfig(rootDir, options) {
             }
           ]);
           if (convertToDir) {
-            const existingRules = await fs7.readFile(rulesPath, "utf-8");
-            await fs7.unlink(rulesPath);
-            await fs7.mkdir(rulesPath);
-            await fs7.writeFile(path7.join(rulesPath, "project.mdc"), existingRules);
-            await fs7.copyFile(templatePath, path7.join(rulesPath, "lien.mdc"));
+            const existingRules = await fs8.readFile(rulesPath, "utf-8");
+            await fs8.unlink(rulesPath);
+            await fs8.mkdir(rulesPath);
+            await fs8.writeFile(path8.join(rulesPath, "project.mdc"), existingRules);
+            await fs8.copyFile(templatePath, path8.join(rulesPath, "lien.mdc"));
             console.log(chalk3.green("\u2713 Converted .cursor/rules to directory"));
             console.log(chalk3.green("  - Your project rules: .cursor/rules/project.mdc"));
             console.log(chalk3.green("  - Lien rules: .cursor/rules/lien.mdc"));
@@ -5439,9 +5562,9 @@ async function createNewConfig(rootDir, options) {
             console.log(chalk3.dim("Skipped Cursor rules installation (preserving existing file)"));
           }
         } else {
-          await fs7.mkdir(rulesPath, { recursive: true });
-          targetPath = path7.join(rulesPath, "lien.mdc");
-          await fs7.copyFile(templatePath, targetPath);
+          await fs8.mkdir(rulesPath, { recursive: true });
+          targetPath = path8.join(rulesPath, "lien.mdc");
+          await fs8.copyFile(templatePath, targetPath);
           console.log(chalk3.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         }
       } catch (error) {
@@ -5455,8 +5578,8 @@ async function createNewConfig(rootDir, options) {
     ...defaultConfig,
     frameworks
   };
-  const configPath = path7.join(rootDir, ".lien.config.json");
-  await fs7.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const configPath = path8.join(rootDir, ".lien.config.json");
+  await fs8.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log(chalk3.green("\n\u2713 Created .lien.config.json"));
   console.log(chalk3.green(`\u2713 Configured ${frameworks.length} framework(s)`));
   console.log(chalk3.dim("\nNext steps:"));
@@ -5494,16 +5617,16 @@ init_service();
 init_utils();
 init_version2();
 import chalk4 from "chalk";
-import fs11 from "fs/promises";
-import path11 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 import os from "os";
 import crypto from "crypto";
 init_schema();
 async function statusCommand() {
   const rootDir = process.cwd();
-  const projectName = path11.basename(rootDir);
+  const projectName = path12.basename(rootDir);
   const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
-  const indexPath = path11.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
+  const indexPath = path12.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
   showCompactBanner();
   console.log(chalk4.bold("Status\n"));
   const hasConfig = await configService.exists(rootDir);
@@ -5513,11 +5636,11 @@ async function statusCommand() {
     return;
   }
   try {
-    const stats = await fs11.stat(indexPath);
+    const stats = await fs12.stat(indexPath);
     console.log(chalk4.dim("Index location:"), indexPath);
     console.log(chalk4.dim("Index status:"), chalk4.green("\u2713 Exists"));
     try {
-      const files = await fs11.readdir(indexPath, { recursive: true });
+      const files = await fs12.readdir(indexPath, { recursive: true });
       console.log(chalk4.dim("Index files:"), files.length);
     } catch (e) {
     }
@@ -5546,9 +5669,9 @@ async function statusCommand() {
         const commit = await getCurrentCommit(rootDir);
         console.log(chalk4.dim("  Current branch:"), branch);
         console.log(chalk4.dim("  Current commit:"), commit.substring(0, 8));
-        const gitStateFile = path11.join(indexPath, ".git-state.json");
+        const gitStateFile = path12.join(indexPath, ".git-state.json");
         try {
-          const gitStateContent = await fs11.readFile(gitStateFile, "utf-8");
+          const gitStateContent = await fs12.readFile(gitStateFile, "utf-8");
           const gitState = JSON.parse(gitStateContent);
           if (gitState.branch !== branch || gitState.commit !== commit) {
             console.log(chalk4.yellow("  \u26A0\uFE0F  Git state changed - will reindex on next serve"));
@@ -5614,8 +5737,8 @@ async function indexCommand(options) {
 
 // src/cli/serve.ts
 import chalk7 from "chalk";
-import fs18 from "fs/promises";
-import path17 from "path";
+import fs19 from "fs/promises";
+import path18 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -5688,6 +5811,17 @@ var ListFunctionsSchema = z4.object({
   )
 });
 
+// src/mcp/schemas/dependents.schema.ts
+import { z as z5 } from "zod";
+var GetDependentsSchema = z5.object({
+  filepath: z5.string().min(1, "Filepath cannot be empty").describe(
+    "Path to file to find dependents for (relative to workspace root).\n\nExample: 'src/utils/validate.ts'\n\nReturns all files that import or depend on this file.\n\nNote: Scans up to 10,000 code chunks. For very large codebases,\nresults may be incomplete (a warning will be included if truncated)."
+  ),
+  depth: z5.number().int().min(1).max(1).default(1).describe(
+    "Depth of transitive dependencies. Only depth=1 (direct dependents) is currently supported.\n\n1 = Direct dependents only"
+  )
+});
+
 // src/mcp/tools.ts
 var tools = [
   toMCPToolSchema(
@@ -5722,15 +5856,39 @@ MANDATORY: Call this BEFORE editing any file. Accepts single path or array of pa
 
 Single file:
   get_files_context({ filepaths: "src/auth.ts" })
+  
+  Returns:
+  {
+    file: "src/auth.ts",
+    chunks: [...],
+    testAssociations: ["src/__tests__/auth.test.ts"]
+  }
 
 Multiple files (batch):
   get_files_context({ filepaths: ["src/auth.ts", "src/user.ts"] })
+  
+  Returns:
+  {
+    files: {
+      "src/auth.ts": {
+        chunks: [...],
+        testAssociations: ["src/__tests__/auth.test.ts"]
+      },
+      "src/user.ts": {
+        chunks: [...],
+        testAssociations: ["src/__tests__/user.test.ts"]
+      }
+    }
+  }
 
 Returns for each file:
 - All chunks and related code
-- testAssociations (which tests cover this file)
+- testAssociations: Array of test files that import this file (reverse dependency lookup)
 - Relevance scoring
 
+ALWAYS check testAssociations before modifying source code.
+After changes, remind the user to run the associated tests.
+
 Batch calls are more efficient than multiple single-file calls.`
   ),
   toMCPToolSchema(
@@ -5743,6 +5901,20 @@ Examples:
 - "Find service classes" \u2192 list_functions({ pattern: ".*Service$" })
 
 10x faster than semantic_search for structural/architectural queries. Use semantic_search instead when searching by what code DOES.`
+  ),
+  toMCPToolSchema(
+    GetDependentsSchema,
+    "get_dependents",
+    `Find all code that depends on a file (reverse dependency lookup). Use for impact analysis:
+- "What breaks if I change this?"
+- "Is this safe to delete?"
+- "What imports this module?"
+
+Returns:
+- List of files that import the target
+- Risk level (low/medium/high/critical) based on dependent count and complexity
+
+Example: get_dependents({ filepath: "src/utils/validate.ts" })`
   )
 ];
 
@@ -5942,6 +6114,50 @@ function wrapToolHandler(schema, handler) {
   };
 }
 
+// src/mcp/utils/path-matching.ts
+function normalizePath(path19, workspaceRoot) {
+  let normalized = path19.replace(/['"]/g, "").trim().replace(/\\/g, "/");
+  normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (normalized.startsWith(workspaceRoot + "/")) {
+    normalized = normalized.substring(workspaceRoot.length + 1);
+  }
+  return normalized;
+}
+function matchesAtBoundary(str, pattern) {
+  const index = str.indexOf(pattern);
+  if (index === -1) return false;
+  const charBefore = index > 0 ? str[index - 1] : "/";
+  if (charBefore !== "/" && index !== 0) return false;
+  const endIndex = index + pattern.length;
+  if (endIndex === str.length) return true;
+  const charAfter = str[endIndex];
+  return charAfter === "/";
+}
+function matchesFile(normalizedImport, normalizedTarget) {
+  if (normalizedImport === normalizedTarget) return true;
+  if (matchesAtBoundary(normalizedImport, normalizedTarget)) {
+    return true;
+  }
+  if (matchesAtBoundary(normalizedTarget, normalizedImport)) {
+    return true;
+  }
+  const cleanedImport = normalizedImport.replace(/^(\.\.?\/)+/, "");
+  if (matchesAtBoundary(cleanedImport, normalizedTarget) || matchesAtBoundary(normalizedTarget, cleanedImport)) {
+    return true;
+  }
+  return false;
+}
+function getCanonicalPath(filepath, workspaceRoot) {
+  let canonical = filepath.replace(/\\/g, "/");
+  if (canonical.startsWith(workspaceRoot + "/")) {
+    canonical = canonical.substring(workspaceRoot.length + 1);
+  }
+  return canonical;
+}
+function isTestFile2(filepath) {
+  return /\.(test|spec)\.[^/]+$/.test(filepath) || /(^|[/\\])(test|tests|__tests__)[/\\]/.test(filepath);
+}
+
 // src/mcp/server.ts
 init_errors();
 var __filename4 = fileURLToPath4(import.meta.url);
@@ -5953,6 +6169,31 @@ try {
 } catch {
   packageJson3 = require4(join3(__dirname4, "../../package.json"));
 }
+var DEPENDENT_COUNT_THRESHOLDS = {
+  LOW: 5,
+  // Few dependents, safe to change
+  MEDIUM: 15,
+  // Moderate impact, review dependents
+  HIGH: 30
+  // High impact, careful planning needed
+};
+var COMPLEXITY_THRESHOLDS = {
+  HIGH_COMPLEXITY_DEPENDENT: 10,
+  // Individual file is complex
+  CRITICAL_AVG: 15,
+  // Average complexity indicates systemic complexity
+  CRITICAL_MAX: 25,
+  // Peak complexity indicates hotspot
+  HIGH_AVG: 10,
+  // Moderately complex on average
+  HIGH_MAX: 20,
+  // Some complex functions exist
+  MEDIUM_AVG: 6,
+  // Slightly above simple code
+  MEDIUM_MAX: 15
+  // Occasional branching
+};
+var SCAN_LIMIT = 1e4;
 async function startMCPServer(options) {
   const { rootDir, verbose, watch } = options;
   const log = (message) => {
@@ -6049,6 +6290,7 @@ async function startMCPServer(options) {
               const isSingleFile = !Array.isArray(validatedArgs.filepaths);
               log(`Getting context for: ${filepaths.join(", ")}`);
               await checkAndReconnect();
+              const workspaceRoot = process.cwd().replace(/\\/g, "/");
               const fileEmbeddings = await Promise.all(filepaths.map((fp) => embeddings.embed(fp)));
               const allFileSearches = await Promise.all(
                 fileEmbeddings.map(
@@ -6057,9 +6299,11 @@ async function startMCPServer(options) {
               );
               const fileChunksMap = filepaths.map((filepath, i) => {
                 const allResults = allFileSearches[i];
-                return allResults.filter(
-                  (r) => r.metadata.file.includes(filepath) || filepath.includes(r.metadata.file)
-                );
+                const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
+                return allResults.filter((r) => {
+                  const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
+                  return chunkCanonical === targetCanonical;
+                });
               });
               let relatedChunksMap = [];
               if (validatedArgs.includeRelated) {
@@ -6076,18 +6320,57 @@ async function startMCPServer(options) {
                   relatedChunksMap = Array.from({ length: filepaths.length }, () => []);
                   filesWithChunks.forEach(({ filepath, index }, i) => {
                     const related = relatedSearches[i];
-                    relatedChunksMap[index] = related.filter(
-                      (r) => !r.metadata.file.includes(filepath) && !filepath.includes(r.metadata.file)
-                    );
+                    const targetCanonical = getCanonicalPath(filepath, workspaceRoot);
+                    relatedChunksMap[index] = related.filter((r) => {
+                      const chunkCanonical = getCanonicalPath(r.metadata.file, workspaceRoot);
+                      return chunkCanonical !== targetCanonical;
+                    });
                   });
                 }
               }
+              const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
+              if (allChunks.length === SCAN_LIMIT) {
+                log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`);
+              }
+              const pathCache = /* @__PURE__ */ new Map();
+              const normalizePathCached = (path19) => {
+                if (pathCache.has(path19)) return pathCache.get(path19);
+                const normalized = normalizePath(path19, workspaceRoot);
+                pathCache.set(path19, normalized);
+                return normalized;
+              };
+              const testAssociationsMap = filepaths.map((filepath) => {
+                const normalizedTarget = normalizePathCached(filepath);
+                const testFiles = /* @__PURE__ */ new Set();
+                for (const chunk of allChunks) {
+                  const chunkFile2 = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+                  if (!isTestFile2(chunkFile2)) continue;
+                  const imports = chunk.metadata.imports || [];
+                  for (const imp of imports) {
+                    const normalizedImport = normalizePathCached(imp);
+                    if (matchesFile(normalizedImport, normalizedTarget)) {
+                      testFiles.add(chunkFile2);
+                      break;
+                    }
+                  }
+                }
+                return Array.from(testFiles);
+              });
               const filesData = {};
               filepaths.forEach((filepath, i) => {
                 const fileChunks = fileChunksMap[i];
                 const relatedChunks = relatedChunksMap[i] || [];
+                const seenChunks = /* @__PURE__ */ new Set();
+                const dedupedChunks = [...fileChunks, ...relatedChunks].filter((chunk) => {
+                  const canonicalFile = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+                  const chunkId = `${canonicalFile}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+                  if (seenChunks.has(chunkId)) return false;
+                  seenChunks.add(chunkId);
+                  return true;
+                });
                 filesData[filepath] = {
-                  chunks: [...fileChunks, ...relatedChunks]
+                  chunks: dedupedChunks,
+                  testAssociations: testAssociationsMap[i]
                 };
               });
               log(`Found ${Object.values(filesData).reduce((sum, f) => sum + f.chunks.length, 0)} total chunks`);
@@ -6096,7 +6379,8 @@ async function startMCPServer(options) {
                 return {
                   indexInfo: getIndexMetadata(),
                   file: filepath,
-                  chunks: filesData[filepath].chunks
+                  chunks: filesData[filepath].chunks,
+                  testAssociations: filesData[filepath].testAssociations
                 };
               } else {
                 return {
@@ -6147,6 +6431,144 @@ async function startMCPServer(options) {
               };
             }
           )(args);
+        case "get_dependents":
+          return await wrapToolHandler(
+            GetDependentsSchema,
+            async (validatedArgs) => {
+              log(`Finding dependents of: ${validatedArgs.filepath}`);
+              await checkAndReconnect();
+              const allChunks = await vectorDB.scanWithFilter({ limit: SCAN_LIMIT });
+              if (allChunks.length === SCAN_LIMIT) {
+                log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Results may be incomplete for large codebases.`);
+              }
+              log(`Scanning ${allChunks.length} chunks for imports...`);
+              const workspaceRoot = process.cwd().replace(/\\/g, "/");
+              const pathCache = /* @__PURE__ */ new Map();
+              const normalizePathCached = (path19) => {
+                if (pathCache.has(path19)) return pathCache.get(path19);
+                const normalized = normalizePath(path19, workspaceRoot);
+                pathCache.set(path19, normalized);
+                return normalized;
+              };
+              const importIndex = /* @__PURE__ */ new Map();
+              for (const chunk of allChunks) {
+                const imports = chunk.metadata.imports || [];
+                for (const imp of imports) {
+                  const normalizedImport = normalizePathCached(imp);
+                  if (!importIndex.has(normalizedImport)) {
+                    importIndex.set(normalizedImport, []);
+                  }
+                  importIndex.get(normalizedImport).push(chunk);
+                }
+              }
+              const normalizedTarget = normalizePathCached(validatedArgs.filepath);
+              const dependentChunks = [];
+              const seenChunkIds = /* @__PURE__ */ new Set();
+              if (importIndex.has(normalizedTarget)) {
+                for (const chunk of importIndex.get(normalizedTarget)) {
+                  const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+                  if (!seenChunkIds.has(chunkId)) {
+                    dependentChunks.push(chunk);
+                    seenChunkIds.add(chunkId);
+                  }
+                }
+              }
+              for (const [normalizedImport, chunks] of importIndex.entries()) {
+                if (normalizedImport !== normalizedTarget && matchesFile(normalizedImport, normalizedTarget)) {
+                  for (const chunk of chunks) {
+                    const chunkId = `${chunk.metadata.file}:${chunk.metadata.startLine}-${chunk.metadata.endLine}`;
+                    if (!seenChunkIds.has(chunkId)) {
+                      dependentChunks.push(chunk);
+                      seenChunkIds.add(chunkId);
+                    }
+                  }
+                }
+              }
+              const chunksByFile = /* @__PURE__ */ new Map();
+              for (const chunk of dependentChunks) {
+                const canonical = getCanonicalPath(chunk.metadata.file, workspaceRoot);
+                const existing = chunksByFile.get(canonical) || [];
+                existing.push(chunk);
+                chunksByFile.set(canonical, existing);
+              }
+              const fileComplexities = [];
+              for (const [filepath, chunks] of chunksByFile.entries()) {
+                const complexities = chunks.map((c) => c.metadata.complexity).filter((c) => typeof c === "number" && c > 0);
+                if (complexities.length > 0) {
+                  const sum = complexities.reduce((a, b) => a + b, 0);
+                  const avg = sum / complexities.length;
+                  const max = Math.max(...complexities);
+                  fileComplexities.push({
+                    filepath,
+                    avgComplexity: Math.round(avg * 10) / 10,
+                    // Round to 1 decimal
+                    maxComplexity: max,
+                    complexityScore: sum,
+                    chunksWithComplexity: complexities.length
+                  });
+                }
+              }
+              let complexityMetrics;
+              if (fileComplexities.length > 0) {
+                const allAvgs = fileComplexities.map((f) => f.avgComplexity);
+                const allMaxes = fileComplexities.map((f) => f.maxComplexity);
+                const totalAvg = allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length;
+                const globalMax = Math.max(...allMaxes);
+                const highComplexityDependents = fileComplexities.filter((f) => f.maxComplexity > COMPLEXITY_THRESHOLDS.HIGH_COMPLEXITY_DEPENDENT).sort((a, b) => b.maxComplexity - a.maxComplexity).slice(0, 5).map((f) => ({
+                  filepath: f.filepath,
+                  maxComplexity: f.maxComplexity,
+                  avgComplexity: f.avgComplexity
+                }));
+                let complexityRiskBoost = "low";
+                if (totalAvg > COMPLEXITY_THRESHOLDS.CRITICAL_AVG || globalMax > COMPLEXITY_THRESHOLDS.CRITICAL_MAX) {
+                  complexityRiskBoost = "critical";
+                } else if (totalAvg > COMPLEXITY_THRESHOLDS.HIGH_AVG || globalMax > COMPLEXITY_THRESHOLDS.HIGH_MAX) {
+                  complexityRiskBoost = "high";
+                } else if (totalAvg > COMPLEXITY_THRESHOLDS.MEDIUM_AVG || globalMax > COMPLEXITY_THRESHOLDS.MEDIUM_MAX) {
+                  complexityRiskBoost = "medium";
+                }
+                complexityMetrics = {
+                  averageComplexity: Math.round(totalAvg * 10) / 10,
+                  maxComplexity: globalMax,
+                  filesWithComplexityData: fileComplexities.length,
+                  highComplexityDependents,
+                  complexityRiskBoost
+                };
+              } else {
+                complexityMetrics = {
+                  averageComplexity: 0,
+                  maxComplexity: 0,
+                  filesWithComplexityData: 0,
+                  highComplexityDependents: [],
+                  complexityRiskBoost: "low"
+                };
+              }
+              const uniqueFiles = Array.from(chunksByFile.keys()).map((filepath) => ({
+                filepath,
+                isTestFile: isTestFile2(filepath)
+              }));
+              const count = uniqueFiles.length;
+              let riskLevel = count === 0 ? "low" : count <= DEPENDENT_COUNT_THRESHOLDS.LOW ? "low" : count <= DEPENDENT_COUNT_THRESHOLDS.MEDIUM ? "medium" : count <= DEPENDENT_COUNT_THRESHOLDS.HIGH ? "high" : "critical";
+              const RISK_ORDER = { low: 0, medium: 1, high: 2, critical: 3 };
+              if (RISK_ORDER[complexityMetrics.complexityRiskBoost] > RISK_ORDER[riskLevel]) {
+                riskLevel = complexityMetrics.complexityRiskBoost;
+              }
+              log(`Found ${count} dependent files (risk: ${riskLevel}${complexityMetrics.filesWithComplexityData > 0 ? ", complexity-boosted" : ""})`);
+              let note;
+              if (allChunks.length === SCAN_LIMIT) {
+                note = `Warning: Scanned ${SCAN_LIMIT} chunks (limit reached). Results may be incomplete for large codebases. Some dependents might not be listed.`;
+              }
+              return {
+                indexInfo: getIndexMetadata(),
+                filepath: validatedArgs.filepath,
+                dependentCount: count,
+                riskLevel,
+                dependents: uniqueFiles,
+                complexityMetrics,
+                note
+              };
+            }
+          )(args);
         default:
           throw new LienError(
             `Unknown tool: ${name}`,
@@ -6319,11 +6741,11 @@ async function startMCPServer(options) {
 
 // src/cli/serve.ts
 async function serveCommand(options) {
-  const rootDir = options.root ? path17.resolve(options.root) : process.cwd();
+  const rootDir = options.root ? path18.resolve(options.root) : process.cwd();
   try {
     if (options.root) {
       try {
-        const stats = await fs18.stat(rootDir);
+        const stats = await fs19.stat(rootDir);
         if (!stats.isDirectory()) {
           console.error(chalk7.red(`Error: --root path is not a directory: ${rootDir}`));
           process.exit(1);