@liendev/lien 0.17.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";
@@ -5992,8 +6115,8 @@ function wrapToolHandler(schema, handler) {
 }
 
 // src/mcp/utils/path-matching.ts
-function normalizePath(path18, workspaceRoot) {
-  let normalized = path18.replace(/['"]/g, "").trim().replace(/\\/g, "/");
+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);
@@ -6210,10 +6333,10 @@ async function startMCPServer(options) {
                 log(`WARNING: Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`);
               }
               const pathCache = /* @__PURE__ */ new Map();
-              const normalizePathCached = (path18) => {
-                if (pathCache.has(path18)) return pathCache.get(path18);
-                const normalized = normalizePath(path18, workspaceRoot);
-                pathCache.set(path18, normalized);
+              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) => {
@@ -6321,10 +6444,10 @@ async function startMCPServer(options) {
               log(`Scanning ${allChunks.length} chunks for imports...`);
               const workspaceRoot = process.cwd().replace(/\\/g, "/");
               const pathCache = /* @__PURE__ */ new Map();
-              const normalizePathCached = (path18) => {
-                if (pathCache.has(path18)) return pathCache.get(path18);
-                const normalized = normalizePath(path18, workspaceRoot);
-                pathCache.set(path18, normalized);
+              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();
@@ -6618,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);