@liendev/lien 0.9.0 → 0.10.0

package/dist/index.js

@@ -329,8 +329,8 @@ var init_errors = __esm({
 });
 
 // src/config/service.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+import fs6 from "fs/promises";
+import path6 from "path";
 var ConfigService, configService;
 var init_service = __esm({
   "src/config/service.ts"() {
@@ -352,13 +352,13 @@ var init_service = __esm({
       async load(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs5.readFile(configPath, "utf-8");
+          const configContent = await fs6.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 = path5.basename(result.backupPath);
+              const backupFilename = path6.basename(result.backupPath);
               console.log(`\u2705 Migration complete! Backup saved as ${backupFilename}`);
               console.log("\u{1F4DD} Your config now uses the framework-based structure.");
             }
@@ -414,7 +414,7 @@ ${validation.errors.join("\n")}`,
         }
         try {
           const configJson = JSON.stringify(config, null, 2) + "\n";
-          await fs5.writeFile(configPath, configJson, "utf-8");
+          await fs6.writeFile(configPath, configJson, "utf-8");
         } catch (error) {
           throw wrapError(error, "Failed to save configuration", { path: configPath });
         }
@@ -428,7 +428,7 @@ ${validation.errors.join("\n")}`,
       async exists(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          await fs5.access(configPath);
+          await fs6.access(configPath);
           return true;
         } catch {
           return false;
@@ -445,7 +445,7 @@ ${validation.errors.join("\n")}`,
       async migrate(rootDir = process.cwd()) {
         const configPath = this.getConfigPath(rootDir);
         try {
-          const configContent = await fs5.readFile(configPath, "utf-8");
+          const configContent = await fs6.readFile(configPath, "utf-8");
           const oldConfig = JSON.parse(configContent);
           if (!this.needsMigration(oldConfig)) {
             return {
@@ -463,7 +463,7 @@ ${validation.errors.join("\n")}`,
             );
           }
           const backupPath = `${configPath}.v0.2.0.backup`;
-          await fs5.copyFile(configPath, backupPath);
+          await fs6.copyFile(configPath, backupPath);
           await this.save(rootDir, newConfig);
           return {
             migrated: true,
@@ -561,7 +561,7 @@ ${validation.errors.join("\n")}`,
        * Get the full path to the config file
        */
       getConfigPath(rootDir) {
-        return path5.join(rootDir, _ConfigService.CONFIG_FILENAME);
+        return path6.join(rootDir, _ConfigService.CONFIG_FILENAME);
       }
       /**
        * Validate modern (v0.3.0+) configuration
@@ -725,7 +725,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 (path5.isAbsolute(fw.path)) {
+          } else if (path6.isAbsolute(fw.path)) {
             errors.push(`frameworks[${index}].path must be relative, got: ${fw.path}`);
           }
           if (fw.enabled === void 0) {
@@ -773,21 +773,21 @@ ${validation.errors.join("\n")}`,
 });
 
 // src/vectordb/version.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 async function writeVersionFile(indexPath) {
   try {
-    const versionFilePath = path7.join(indexPath, VERSION_FILE);
+    const versionFilePath = path8.join(indexPath, VERSION_FILE);
     const timestamp = Date.now().toString();
-    await fs7.writeFile(versionFilePath, timestamp, "utf-8");
+    await fs8.writeFile(versionFilePath, timestamp, "utf-8");
   } catch (error) {
     console.error(`Warning: Failed to write version file: ${error}`);
   }
 }
 async function readVersionFile(indexPath) {
   try {
-    const versionFilePath = path7.join(indexPath, VERSION_FILE);
-    const content = await fs7.readFile(versionFilePath, "utf-8");
+    const versionFilePath = path8.join(indexPath, VERSION_FILE);
+    const content = await fs8.readFile(versionFilePath, "utf-8");
     const timestamp = parseInt(content.trim(), 10);
     return isNaN(timestamp) ? 0 : timestamp;
   } catch (error) {
@@ -805,8 +805,8 @@ var init_version = __esm({
 // src/indexer/scanner.ts
 import { glob } from "glob";
 import ignore from "ignore";
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 async function scanCodebaseWithFrameworks(rootDir, config) {
   const allFiles = [];
   for (const framework of config.frameworks) {
@@ -819,16 +819,16 @@ async function scanCodebaseWithFrameworks(rootDir, config) {
   return allFiles;
 }
 async function scanFramework(rootDir, framework) {
-  const frameworkPath = path9.join(rootDir, framework.path);
-  const gitignorePath = path9.join(frameworkPath, ".gitignore");
+  const frameworkPath = path10.join(rootDir, framework.path);
+  const gitignorePath = path10.join(frameworkPath, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs9.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs10.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
-    const rootGitignorePath = path9.join(rootDir, ".gitignore");
+    const rootGitignorePath = path10.join(rootDir, ".gitignore");
     try {
-      const gitignoreContent = await fs9.readFile(rootGitignorePath, "utf-8");
+      const gitignoreContent = await fs10.readFile(rootGitignorePath, "utf-8");
       ig = ignore().add(gitignoreContent);
     } catch (e2) {
     }
@@ -850,15 +850,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 : path9.join(framework.path, file);
+    return framework.path === "." ? file : path10.join(framework.path, file);
   });
 }
 async function scanCodebase(options) {
   const { rootDir, includePatterns = [], excludePatterns = [] } = options;
-  const gitignorePath = path9.join(rootDir, ".gitignore");
+  const gitignorePath = path10.join(rootDir, ".gitignore");
   let ig = ignore();
   try {
-    const gitignoreContent = await fs9.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs10.readFile(gitignorePath, "utf-8");
     ig = ignore().add(gitignoreContent);
   } catch (e) {
   }
@@ -885,12 +885,12 @@ async function scanCodebase(options) {
   }
   const uniqueFiles = Array.from(new Set(allFiles));
   return uniqueFiles.filter((file) => {
-    const relativePath = path9.relative(rootDir, file);
+    const relativePath = path10.relative(rootDir, file);
     return !ig.ignores(relativePath);
   });
 }
 function detectLanguage(filepath) {
-  const ext = path9.extname(filepath).toLowerCase();
+  const ext = path10.extname(filepath).toLowerCase();
   const languageMap = {
     ".ts": "typescript",
     ".tsx": "typescript",
@@ -915,6 +915,7 @@ function detectLanguage(filepath) {
     ".kt": "kotlin",
     ".cs": "csharp",
     ".scala": "scala",
+    ".liquid": "liquid",
     ".md": "markdown",
     ".mdx": "markdown",
     ".markdown": "markdown"
@@ -1380,12 +1381,12 @@ __export(lancedb_exports, {
   VectorDB: () => VectorDB
 });
 import * as lancedb from "vectordb";
-import path10 from "path";
+import path11 from "path";
 import os2 from "os";
 import crypto2 from "crypto";
 function isDocumentationFile(filepath) {
   const lower = filepath.toLowerCase();
-  const filename = path10.basename(filepath).toLowerCase();
+  const filename = path11.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")) {
@@ -1432,7 +1433,7 @@ function boostPathRelevance(query, filepath, baseScore) {
   return baseScore * boostFactor;
 }
 function boostFilenameRelevance(query, filepath, baseScore) {
-  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   let boostFactor = 1;
   for (const token of queryTokens) {
@@ -1447,7 +1448,7 @@ function boostFilenameRelevance(query, filepath, baseScore) {
 }
 function boostForLocationIntent(query, filepath, baseScore) {
   let score = baseScore;
-  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
@@ -1475,7 +1476,7 @@ function boostForConceptualIntent(query, filepath, baseScore) {
   if (isUtilityFile(filepath)) {
     score *= 1.05;
   }
-  const filename = path10.basename(filepath, path10.extname(filepath)).toLowerCase();
+  const filename = path11.basename(filepath, path11.extname(filepath)).toLowerCase();
   const queryTokens = query.toLowerCase().split(/\s+/);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
@@ -1483,7 +1484,7 @@ function boostForConceptualIntent(query, filepath, baseScore) {
       score *= 0.9;
     }
   }
-  const pathSegments = filepath.toLowerCase().split(path10.sep);
+  const pathSegments = filepath.toLowerCase().split(path11.sep);
   for (const token of queryTokens) {
     if (token.length <= 2) continue;
     for (const segment of pathSegments) {
@@ -1537,9 +1538,9 @@ var init_lancedb = __esm({
       lastVersionCheck = 0;
       currentVersion = 0;
       constructor(projectRoot) {
-        const projectName = path10.basename(projectRoot);
+        const projectName = path11.basename(projectRoot);
         const pathHash = crypto2.createHash("md5").update(projectRoot).digest("hex").substring(0, 8);
-        this.dbPath = path10.join(
+        this.dbPath = path11.join(
           os2.homedir(),
           ".lien",
           "indices",
@@ -1897,7 +1898,7 @@ var indexer_exports = {};
 __export(indexer_exports, {
   indexCodebase: () => indexCodebase
 });
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 import ora from "ora";
 import chalk4 from "chalk";
 import pLimit from "p-limit";
@@ -1963,7 +1964,7 @@ async function indexCodebase(options = {}) {
     const filePromises = files.map(
       (file) => limit(async () => {
         try {
-          const content = await fs10.readFile(file, "utf-8");
+          const content = await fs11.readFile(file, "utf-8");
           const chunkSize = isModernConfig(config) ? config.core.chunkSize : 75;
           const chunkOverlap = isModernConfig(config) ? config.core.chunkOverlap : 10;
           const chunks = chunkFile(file, content, {
@@ -2034,15 +2035,15 @@ init_schema();
 init_merge();
 init_banner();
 init_migration();
-import fs4 from "fs/promises";
-import path4 from "path";
+import fs5 from "fs/promises";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk2 from "chalk";
 import inquirer from "inquirer";
 
 // src/frameworks/detector-service.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs4 from "fs/promises";
+import path4 from "path";
 
 // src/frameworks/types.ts
 var defaultDetectionOptions = {
@@ -2071,24 +2072,17 @@ import path from "path";
 async function generateNodeJsConfig(_rootDir, _relativePath) {
   return {
     include: [
-      "src/**/*.ts",
-      "src/**/*.tsx",
-      "src/**/*.js",
-      "src/**/*.jsx",
-      "src/**/*.mjs",
-      "src/**/*.cjs",
-      "lib/**/*.ts",
-      "lib/**/*.js",
-      "*.ts",
-      "*.js",
-      "*.mjs",
-      "*.cjs",
+      // Broader patterns to catch all common project structures
+      // (frontend/, src/, lib/, app/, components/, etc.)
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.vue",
+      "**/*.mjs",
+      "**/*.cjs",
       "**/*.md",
-      "**/*.mdx",
-      "docs/**/*.md",
-      "README.md",
-      "CHANGELOG.md",
-      "CONTRIBUTING.md"
+      "**/*.mdx"
     ],
     exclude: [
       "node_modules/**",
@@ -2097,10 +2091,22 @@ async function generateNodeJsConfig(_rootDir, _relativePath) {
       "coverage/**",
       ".next/**",
       ".nuxt/**",
+      ".vite/**",
+      ".lien/**",
       "out/**",
       "*.min.js",
       "*.min.css",
-      "*.bundle.js"
+      "*.bundle.js",
+      // Test artifacts (source files are indexed, but not output)
+      "playwright-report/**",
+      "test-results/**",
+      // Build/generated artifacts
+      "__generated__/**",
+      // Common build/cache directories
+      ".cache/**",
+      ".turbo/**",
+      ".vercel/**",
+      ".netlify/**"
     ]
   };
 }
@@ -2185,12 +2191,12 @@ async function generateLaravelConfig(_rootDir, _relativePath) {
       "resources/**/*.php",
       "tests/**/*.php",
       "*.php",
-      // Frontend assets (Vue/React/Inertia)
-      "resources/js/**/*.js",
-      "resources/js/**/*.ts",
-      "resources/js/**/*.jsx",
-      "resources/js/**/*.tsx",
-      "resources/js/**/*.vue",
+      // Frontend assets (Vue/React/Inertia) - Broadened for flexibility
+      "**/*.js",
+      "**/*.ts",
+      "**/*.jsx",
+      "**/*.tsx",
+      "**/*.vue",
       // Blade templates
       "resources/views/**/*.blade.php",
       // Documentation
@@ -2205,7 +2211,19 @@ async function generateLaravelConfig(_rootDir, _relativePath) {
       "storage/**",
       "bootstrap/cache/**",
       "public/**",
-      "node_modules/**"
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      // Test artifacts (source files are indexed, but not output)
+      "playwright-report/**",
+      "test-results/**",
+      "coverage/**",
+      // Build/generated artifacts
+      "__generated__/**",
+      // Frontend build outputs
+      ".vite/**",
+      ".nuxt/**",
+      ".next/**"
     ]
   };
 }
@@ -2287,10 +2305,142 @@ var laravelDetector = {
   }
 };
 
+// src/frameworks/shopify/detector.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/frameworks/shopify/config.ts
+async function generateShopifyConfig(_rootDir, _relativePath) {
+  return {
+    include: [
+      // Core Liquid templates
+      "layout/**/*.liquid",
+      "sections/**/*.liquid",
+      "snippets/**/*.liquid",
+      "templates/**/*.liquid",
+      // Matches any nesting level (e.g., templates/customers/account.liquid)
+      // Theme editor blocks (Online Store 2.0)
+      "blocks/**/*.liquid",
+      // Assets (CSS, JS with optional Liquid templating)
+      "assets/**/*.js",
+      "assets/**/*.js.liquid",
+      "assets/**/*.css",
+      "assets/**/*.css.liquid",
+      "assets/**/*.scss",
+      "assets/**/*.scss.liquid",
+      // Configuration files
+      "config/*.json",
+      // Locales (i18n)
+      "locales/*.json",
+      // Documentation
+      "*.md",
+      "docs/**/*.md",
+      // Shopify-specific config files
+      "shopify.theme.toml",
+      ".shopifyignore"
+    ],
+    exclude: [
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      ".git/**",
+      // Playwright/testing artifacts
+      "playwright-report/**",
+      "test-results/**",
+      // Build/generated artifacts
+      "__generated__/**",
+      // Common frontend build outputs
+      ".vite/**",
+      ".nuxt/**",
+      ".next/**"
+    ]
+  };
+}
+
+// src/frameworks/shopify/detector.ts
+var shopifyDetector = {
+  name: "shopify",
+  priority: 100,
+  // High priority (same as Laravel)
+  async detect(rootDir, relativePath) {
+    const fullPath = path3.join(rootDir, relativePath);
+    const result = {
+      detected: false,
+      name: "shopify",
+      path: relativePath,
+      confidence: "low",
+      evidence: []
+    };
+    const settingsSchemaPath = path3.join(fullPath, "config", "settings_schema.json");
+    let hasSettingsSchema = false;
+    try {
+      await fs3.access(settingsSchemaPath);
+      hasSettingsSchema = true;
+      result.evidence.push("Found config/settings_schema.json");
+    } catch {
+    }
+    const themeLayoutPath = path3.join(fullPath, "layout", "theme.liquid");
+    let hasThemeLayout = false;
+    try {
+      await fs3.access(themeLayoutPath);
+      hasThemeLayout = true;
+      result.evidence.push("Found layout/theme.liquid");
+    } catch {
+    }
+    const shopifyDirs = ["sections", "snippets", "templates", "locales"];
+    let foundDirs = 0;
+    for (const dir of shopifyDirs) {
+      try {
+        const dirPath = path3.join(fullPath, dir);
+        const stats = await fs3.stat(dirPath);
+        if (stats.isDirectory()) {
+          foundDirs++;
+        }
+      } catch {
+      }
+    }
+    if (foundDirs >= 2) {
+      result.evidence.push(`Shopify directory structure detected (${foundDirs}/${shopifyDirs.length} dirs)`);
+    }
+    try {
+      const tomlPath = path3.join(fullPath, "shopify.theme.toml");
+      await fs3.access(tomlPath);
+      result.evidence.push("Found shopify.theme.toml");
+    } catch {
+    }
+    try {
+      const ignorePath = path3.join(fullPath, ".shopifyignore");
+      await fs3.access(ignorePath);
+      result.evidence.push("Found .shopifyignore");
+    } catch {
+    }
+    if (hasSettingsSchema && foundDirs >= 2) {
+      result.detected = true;
+      result.confidence = "high";
+      return result;
+    }
+    if (hasSettingsSchema || hasThemeLayout && foundDirs >= 1) {
+      result.detected = true;
+      result.confidence = "medium";
+      return result;
+    }
+    if (foundDirs >= 3) {
+      result.detected = true;
+      result.confidence = "medium";
+      return result;
+    }
+    return result;
+  },
+  async generateConfig(rootDir, relativePath) {
+    return generateShopifyConfig(rootDir, relativePath);
+  }
+};
+
 // src/frameworks/registry.ts
 var frameworkDetectors = [
   nodejsDetector,
-  laravelDetector
+  laravelDetector,
+  shopifyDetector
 ];
 function getFrameworkDetector(name) {
   return frameworkDetectors.find((d) => d.name === name);
@@ -2306,7 +2456,7 @@ async function detectAllFrameworks(rootDir, options = {}) {
   return results;
 }
 async function detectAtPath(rootDir, relativePath, results, visited) {
-  const fullPath = path3.join(rootDir, relativePath);
+  const fullPath = path4.join(rootDir, relativePath);
   if (visited.has(fullPath)) {
     return;
   }
@@ -2326,25 +2476,56 @@ async function detectAtPath(rootDir, relativePath, results, visited) {
     }
   }
   if (detectedAtPath.length > 1) {
-    detectedAtPath.sort((a, b) => b.priority - a.priority);
-    const winner = detectedAtPath[0];
-    results.push(winner);
-    const skipped = detectedAtPath.slice(1);
-    if (skipped.length > 0) {
-      const skippedNames = skipped.map((d) => d.name).join(", ");
-      console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+    const highConfidence = detectedAtPath.filter((d) => d.confidence === "high");
+    const mediumConfidence = detectedAtPath.filter((d) => d.confidence === "medium");
+    const lowConfidence = detectedAtPath.filter((d) => d.confidence === "low");
+    if (highConfidence.length > 1) {
+      const cleanResults = highConfidence.map(({ priority, ...result }) => result);
+      results.push(...cleanResults);
+      const names = highConfidence.map((d) => d.name).join(" + ");
+      console.log(`  \u2192 Detected hybrid project: ${names}`);
+      if (mediumConfidence.length > 0 || lowConfidence.length > 0) {
+        const skippedNames = [...mediumConfidence, ...lowConfidence].map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping lower confidence detections: ${skippedNames}`);
+      }
+    } else if (highConfidence.length === 1) {
+      const { priority, ...result } = highConfidence[0];
+      results.push(result);
+      if (mediumConfidence.length > 0 || lowConfidence.length > 0) {
+        const skippedNames = [...mediumConfidence, ...lowConfidence].map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping lower confidence detections: ${skippedNames}`);
+      }
+    } else if (mediumConfidence.length > 0) {
+      mediumConfidence.sort((a, b) => b.priority - a.priority);
+      const { priority, ...winner } = mediumConfidence[0];
+      results.push(winner);
+      const skipped = [...mediumConfidence.slice(1), ...lowConfidence];
+      if (skipped.length > 0) {
+        const skippedNames = skipped.map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+      }
+    } else if (lowConfidence.length > 0) {
+      lowConfidence.sort((a, b) => b.priority - a.priority);
+      const { priority, ...winner } = lowConfidence[0];
+      results.push(winner);
+      const skipped = lowConfidence.slice(1);
+      if (skipped.length > 0) {
+        const skippedNames = skipped.map((d) => d.name).join(", ");
+        console.log(`  \u2192 Skipping ${skippedNames} at ${relativePath} (${winner.name} takes precedence)`);
+      }
     }
   } else if (detectedAtPath.length === 1) {
-    results.push(detectedAtPath[0]);
+    const { priority, ...result } = detectedAtPath[0];
+    results.push(result);
   }
 }
 async function scanSubdirectories(rootDir, relativePath, results, visited, depth, options) {
   if (depth >= options.maxDepth) {
     return;
   }
-  const fullPath = path3.join(rootDir, relativePath);
+  const fullPath = path4.join(rootDir, relativePath);
   try {
-    const entries = await fs3.readdir(fullPath, { withFileTypes: true });
+    const entries = await fs4.readdir(fullPath, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory());
     for (const dir of dirs) {
       if (options.skipDirs.includes(dir.name)) {
@@ -2353,7 +2534,7 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
       if (dir.name.startsWith(".")) {
         continue;
       }
-      const subPath = relativePath === "." ? dir.name : path3.join(relativePath, dir.name);
+      const subPath = relativePath === "." ? dir.name : path4.join(relativePath, dir.name);
       await detectAtPath(rootDir, subPath, results, visited);
       await scanSubdirectories(rootDir, subPath, results, visited, depth + 1, options);
     }
@@ -2364,14 +2545,14 @@ async function scanSubdirectories(rootDir, relativePath, results, visited, depth
 
 // src/cli/init.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path4.dirname(__filename2);
+var __dirname2 = path5.dirname(__filename2);
 async function initCommand(options = {}) {
   const rootDir = options.path || process.cwd();
-  const configPath = path4.join(rootDir, ".lien.config.json");
+  const configPath = path5.join(rootDir, ".lien.config.json");
   try {
     let configExists = false;
     try {
-      await fs4.access(configPath);
+      await fs5.access(configPath);
       configExists = true;
     } catch {
     }
@@ -2507,22 +2688,22 @@ async function createNewConfig(rootDir, options) {
     ]);
     if (installCursorRules) {
       try {
-        const cursorRulesDir = path4.join(rootDir, ".cursor");
-        await fs4.mkdir(cursorRulesDir, { recursive: true });
-        const templatePath = path4.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
-        const rulesPath = path4.join(cursorRulesDir, "rules");
+        const cursorRulesDir = path5.join(rootDir, ".cursor");
+        await fs5.mkdir(cursorRulesDir, { recursive: true });
+        const templatePath = path5.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
+        const rulesPath = path5.join(cursorRulesDir, "rules");
         let targetPath;
         let isDirectory = false;
         let isFile = false;
         try {
-          const stats = await fs4.stat(rulesPath);
+          const stats = await fs5.stat(rulesPath);
           isDirectory = stats.isDirectory();
           isFile = stats.isFile();
         } catch {
         }
         if (isDirectory) {
-          targetPath = path4.join(rulesPath, "lien.mdc");
-          await fs4.copyFile(templatePath, targetPath);
+          targetPath = path5.join(rulesPath, "lien.mdc");
+          await fs5.copyFile(templatePath, targetPath);
           console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         } else if (isFile) {
           const { convertToDir } = await inquirer.prompt([
@@ -2534,11 +2715,11 @@ async function createNewConfig(rootDir, options) {
             }
           ]);
           if (convertToDir) {
-            const existingRules = await fs4.readFile(rulesPath, "utf-8");
-            await fs4.unlink(rulesPath);
-            await fs4.mkdir(rulesPath);
-            await fs4.writeFile(path4.join(rulesPath, "project.mdc"), existingRules);
-            await fs4.copyFile(templatePath, path4.join(rulesPath, "lien.mdc"));
+            const existingRules = await fs5.readFile(rulesPath, "utf-8");
+            await fs5.unlink(rulesPath);
+            await fs5.mkdir(rulesPath);
+            await fs5.writeFile(path5.join(rulesPath, "project.mdc"), existingRules);
+            await fs5.copyFile(templatePath, path5.join(rulesPath, "lien.mdc"));
             console.log(chalk2.green("\u2713 Converted .cursor/rules to directory"));
             console.log(chalk2.green("  - Your project rules: .cursor/rules/project.mdc"));
             console.log(chalk2.green("  - Lien rules: .cursor/rules/lien.mdc"));
@@ -2546,9 +2727,9 @@ async function createNewConfig(rootDir, options) {
             console.log(chalk2.dim("Skipped Cursor rules installation (preserving existing file)"));
           }
         } else {
-          await fs4.mkdir(rulesPath, { recursive: true });
-          targetPath = path4.join(rulesPath, "lien.mdc");
-          await fs4.copyFile(templatePath, targetPath);
+          await fs5.mkdir(rulesPath, { recursive: true });
+          targetPath = path5.join(rulesPath, "lien.mdc");
+          await fs5.copyFile(templatePath, targetPath);
           console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
         }
       } catch (error) {
@@ -2562,8 +2743,8 @@ async function createNewConfig(rootDir, options) {
     ...defaultConfig,
     frameworks
   };
-  const configPath = path4.join(rootDir, ".lien.config.json");
-  await fs4.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const configPath = path5.join(rootDir, ".lien.config.json");
+  await fs5.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log(chalk2.green("\n\u2713 Created .lien.config.json"));
   console.log(chalk2.green(`\u2713 Configured ${frameworks.length} framework(s)`));
   console.log(chalk2.dim("\nNext steps:"));
@@ -2598,8 +2779,8 @@ Customizing ${frameworkName} settings:`));
 async function upgradeConfig(configPath) {
   try {
     const backupPath = `${configPath}.backup`;
-    await fs4.copyFile(configPath, backupPath);
-    const existingContent = await fs4.readFile(configPath, "utf-8");
+    await fs5.copyFile(configPath, backupPath);
+    const existingContent = await fs5.readFile(configPath, "utf-8");
     const existingConfig = JSON.parse(existingContent);
     let upgradedConfig;
     let migrated = false;
@@ -2615,7 +2796,7 @@ async function upgradeConfig(configPath) {
         newFields.forEach((field) => console.log(chalk2.dim("  \u2022"), chalk2.bold(field)));
       }
     }
-    await fs4.writeFile(
+    await fs5.writeFile(
       configPath,
       JSON.stringify(upgradedConfig, null, 2) + "\n",
       "utf-8"
@@ -2634,21 +2815,21 @@ async function upgradeConfig(configPath) {
 // src/cli/status.ts
 init_service();
 import chalk3 from "chalk";
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 import os from "os";
 import crypto from "crypto";
 
 // src/git/utils.ts
 import { exec } from "child_process";
 import { promisify } from "util";
-import fs6 from "fs/promises";
-import path6 from "path";
+import fs7 from "fs/promises";
+import path7 from "path";
 var execAsync = promisify(exec);
 async function isGitRepo(rootDir) {
   try {
-    const gitDir = path6.join(rootDir, ".git");
-    await fs6.access(gitDir);
+    const gitDir = path7.join(rootDir, ".git");
+    await fs7.access(gitDir);
     return true;
   } catch {
     return false;
@@ -2687,7 +2868,7 @@ async function getChangedFiles(rootDir, fromRef, toRef) {
         // 10 second timeout for diffs
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path6.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files: ${error}`);
@@ -2702,7 +2883,7 @@ async function getChangedFilesBetweenCommits(rootDir, fromCommit, toCommit) {
         timeout: 1e4
       }
     );
-    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path6.join(rootDir, file));
+    const files = stdout.trim().split("\n").filter(Boolean).map((file) => path7.join(rootDir, file));
     return files;
   } catch (error) {
     throw new Error(`Failed to get changed files between commits: ${error}`);
@@ -2723,9 +2904,9 @@ init_banner();
 init_schema();
 async function statusCommand() {
   const rootDir = process.cwd();
-  const projectName = path8.basename(rootDir);
+  const projectName = path9.basename(rootDir);
   const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
-  const indexPath = path8.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
+  const indexPath = path9.join(os.homedir(), ".lien", "indices", `${projectName}-${pathHash}`);
   showCompactBanner();
   console.log(chalk3.bold("Status\n"));
   const hasConfig = await configService.exists(rootDir);
@@ -2735,11 +2916,11 @@ async function statusCommand() {
     return;
   }
   try {
-    const stats = await fs8.stat(indexPath);
+    const stats = await fs9.stat(indexPath);
     console.log(chalk3.dim("Index location:"), indexPath);
     console.log(chalk3.dim("Index status:"), chalk3.green("\u2713 Exists"));
     try {
-      const files = await fs8.readdir(indexPath, { recursive: true });
+      const files = await fs9.readdir(indexPath, { recursive: true });
       console.log(chalk3.dim("Index files:"), files.length);
     } catch (e) {
     }
@@ -2768,9 +2949,9 @@ async function statusCommand() {
         const commit = await getCurrentCommit(rootDir);
         console.log(chalk3.dim("  Current branch:"), branch);
         console.log(chalk3.dim("  Current commit:"), commit.substring(0, 8));
-        const gitStateFile = path8.join(indexPath, ".git-state.json");
+        const gitStateFile = path9.join(indexPath, ".git-state.json");
         try {
-          const gitStateContent = await fs8.readFile(gitStateFile, "utf-8");
+          const gitStateContent = await fs9.readFile(gitStateFile, "utf-8");
           const gitState = JSON.parse(gitStateContent);
           if (gitState.branch !== branch || gitState.commit !== commit) {
             console.log(chalk3.yellow("  \u26A0\uFE0F  Git state changed - will reindex on next serve"));
@@ -2825,6 +3006,8 @@ async function indexCommand(options) {
 
 // src/cli/serve.ts
 import chalk6 from "chalk";
+import fs14 from "fs/promises";
+import path13 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -2920,15 +3103,15 @@ init_lancedb();
 init_local();
 
 // src/git/tracker.ts
-import fs11 from "fs/promises";
-import path11 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 var GitStateTracker = class {
   stateFile;
   rootDir;
   currentState = null;
   constructor(rootDir, indexPath) {
     this.rootDir = rootDir;
-    this.stateFile = path11.join(indexPath, ".git-state.json");
+    this.stateFile = path12.join(indexPath, ".git-state.json");
   }
   /**
    * Loads the last known git state from disk.
@@ -2936,7 +3119,7 @@ var GitStateTracker = class {
    */
   async loadState() {
     try {
-      const content = await fs11.readFile(this.stateFile, "utf-8");
+      const content = await fs12.readFile(this.stateFile, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -2948,7 +3131,7 @@ var GitStateTracker = class {
   async saveState(state) {
     try {
       const content = JSON.stringify(state, null, 2);
-      await fs11.writeFile(this.stateFile, content, "utf-8");
+      await fs12.writeFile(this.stateFile, content, "utf-8");
     } catch (error) {
       console.error(`[Lien] Warning: Failed to save git state: ${error}`);
     }
@@ -3099,12 +3282,12 @@ var GitStateTracker = class {
 // src/indexer/incremental.ts
 init_chunker();
 init_schema();
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 async function indexSingleFile(filepath, vectorDB, embeddings, config, options = {}) {
   const { verbose } = options;
   try {
     try {
-      await fs12.access(filepath);
+      await fs13.access(filepath);
     } catch {
       if (verbose) {
         console.error(`[Lien] File deleted: ${filepath}`);
@@ -3112,7 +3295,7 @@ async function indexSingleFile(filepath, vectorDB, embeddings, config, options =
       await vectorDB.deleteByFile(filepath);
       return;
     }
-    const content = await fs12.readFile(filepath, "utf-8");
+    const content = await fs13.readFile(filepath, "utf-8");
     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;
     const chunks = chunkFile(filepath, content, {
@@ -3353,14 +3536,6 @@ async function startMCPServer(options) {
   const versionCheckInterval = setInterval(async () => {
     await checkAndReconnect();
   }, VERSION_CHECK_INTERVAL_MS);
-  process.on("SIGINT", () => {
-    clearInterval(versionCheckInterval);
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    clearInterval(versionCheckInterval);
-    process.exit(0);
-  });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
@@ -3619,6 +3794,7 @@ async function startMCPServer(options) {
   }
   const cleanup = async () => {
     log("Shutting down MCP server...");
+    clearInterval(versionCheckInterval);
     if (gitPollInterval) {
       clearInterval(gitPollInterval);
     }
@@ -3630,6 +3806,13 @@ async function startMCPServer(options) {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const transport = new StdioServerTransport();
+  transport.onclose = () => {
+    log("Transport closed, parent process likely terminated");
+    cleanup().catch(() => process.exit(0));
+  };
+  transport.onerror = (error) => {
+    log(`Transport error: ${error}`);
+  };
   await server.connect(transport);
   log("MCP server started and listening on stdio");
 }
@@ -3637,10 +3820,33 @@ async function startMCPServer(options) {
 // src/cli/serve.ts
 init_banner();
 async function serveCommand(options) {
-  const rootDir = process.cwd();
+  const rootDir = options.root ? path13.resolve(options.root) : process.cwd();
   try {
+    if (options.root) {
+      try {
+        const stats = await fs14.stat(rootDir);
+        if (!stats.isDirectory()) {
+          console.error(chalk6.red(`Error: --root path is not a directory: ${rootDir}`));
+          process.exit(1);
+        }
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          console.error(chalk6.red(`Error: --root directory does not exist: ${rootDir}`));
+        } else if (error.code === "EACCES") {
+          console.error(chalk6.red(`Error: --root directory is not accessible: ${rootDir}`));
+        } else {
+          console.error(chalk6.red(`Error: Failed to access --root directory: ${rootDir}`));
+          console.error(chalk6.dim(error.message));
+        }
+        process.exit(1);
+      }
+    }
     showBanner();
     console.error(chalk6.bold("Starting MCP server...\n"));
+    if (options.root) {
+      console.error(chalk6.dim(`Serving from: ${rootDir}
+`));
+    }
     await startMCPServer({
       rootDir,
       verbose: true,
@@ -3666,7 +3872,7 @@ var program = new Command();
 program.name("lien").description("Local semantic code search for AI assistants via MCP").version(packageJson3.version);
 program.command("init").description("Initialize Lien in the current directory").option("-u, --upgrade", "Upgrade existing config with new options").option("-y, --yes", "Skip interactive prompts and use defaults").option("-p, --path <path>", "Path to initialize (defaults to current directory)").action(initCommand);
 program.command("index").description("Index the codebase for semantic search").option("-w, --watch", "Watch for changes and re-index automatically").option("-v, --verbose", "Show detailed logging during indexing").action(indexCommand);
-program.command("serve").description("Start the MCP server for Cursor integration").option("-p, --port <port>", "Port number (for future use)", "7133").option("-w, --watch", "Enable file watching for real-time reindexing").action(serveCommand);
+program.command("serve").description("Start the MCP server for Cursor integration").option("-p, --port <port>", "Port number (for future use)", "7133").option("-w, --watch", "Enable file watching for real-time reindexing").option("-r, --root <path>", "Root directory to serve (defaults to current directory)").action(serveCommand);
 program.command("status").description("Show indexing status and statistics").action(statusCommand);
 program.command("reindex").description("Clear index and re-index the entire codebase").option("-v, --verbose", "Show detailed logging during indexing").action(async (options) => {
   const { showCompactBanner: showCompactBanner2 } = await Promise.resolve().then(() => (init_banner(), banner_exports));