@liendev/lien 0.19.2 → 0.19.4

package/dist/index.js

@@ -994,7 +994,7 @@ async function scanCodebaseWithFrameworks(rootDir, config) {
     const frameworkFiles = await scanFramework(rootDir, framework);
     allFiles.push(...frameworkFiles);
   }
-  return allFiles;
+  return Array.from(new Set(allFiles));
 }
 async function scanFramework(rootDir, framework) {
   const frameworkPath = path13.join(rootDir, framework.path);
@@ -2766,90 +2766,89 @@ function findLiquidBlocks(content) {
   }
   return blocks.sort((a, b) => a.startLine - b.startLine);
 }
-function chunkLiquidFile(filepath, content, chunkSize = 75, chunkOverlap = 10) {
-  const lines = content.split("\n");
-  const blocks = findLiquidBlocks(content);
+function createCodeChunk(content, startLine, endLine, filepath, type, options = {}) {
+  return {
+    content,
+    metadata: {
+      file: filepath,
+      startLine,
+      endLine,
+      language: "liquid",
+      type,
+      symbolName: options.symbolName,
+      symbolType: options.symbolType,
+      imports: options.imports?.length ? options.imports : void 0
+    }
+  };
+}
+function splitLargeBlock(block, ctx, symbolName, imports) {
   const chunks = [];
-  const contentWithoutComments = removeComments(content);
-  const linesWithoutComments = contentWithoutComments.split("\n");
-  const coveredLines = /* @__PURE__ */ new Set();
-  for (const block of blocks) {
-    for (let i = block.startLine; i <= block.endLine; i++) {
-      coveredLines.add(i);
-    }
-    let symbolName;
-    if (block.type === "schema") {
-      symbolName = extractSchemaName(block.content);
-    }
-    const blockContentWithoutComments = linesWithoutComments.slice(block.startLine, block.endLine + 1).join("\n");
-    const imports = extractRenderTags(blockContentWithoutComments);
-    const blockLineCount = block.endLine - block.startLine + 1;
-    const maxBlockSize = chunkSize * 3;
-    if (blockLineCount <= maxBlockSize) {
-      chunks.push({
-        content: block.content,
-        metadata: {
-          file: filepath,
-          startLine: block.startLine + 1,
-          // 1-indexed
-          endLine: block.endLine + 1,
-          language: "liquid",
-          type: "block",
-          symbolName,
-          symbolType: block.type,
-          imports: imports.length > 0 ? imports : void 0
-        }
-      });
-    } else {
-      const blockLines = block.content.split("\n");
-      for (let offset = 0; offset < blockLines.length; offset += chunkSize - chunkOverlap) {
-        const endOffset = Math.min(offset + chunkSize, blockLines.length);
-        const chunkContent = blockLines.slice(offset, endOffset).join("\n");
-        if (chunkContent.trim().length > 0) {
-          chunks.push({
-            content: chunkContent,
-            metadata: {
-              file: filepath,
-              startLine: block.startLine + offset + 1,
-              // 1-indexed
-              endLine: block.startLine + endOffset,
-              // 1-indexed (endOffset already accounts for exclusivity)
-              language: "liquid",
-              type: "block",
-              symbolName,
-              // Preserve symbol name for all split chunks
-              symbolType: block.type,
-              imports: imports.length > 0 ? imports : void 0
-            }
-          });
-        }
-        if (endOffset >= blockLines.length) break;
-      }
+  const blockLines = block.content.split("\n");
+  const { chunkSize, chunkOverlap, filepath } = ctx.params;
+  for (let offset = 0; offset < blockLines.length; offset += chunkSize - chunkOverlap) {
+    const endOffset = Math.min(offset + chunkSize, blockLines.length);
+    const chunkContent = blockLines.slice(offset, endOffset).join("\n");
+    if (chunkContent.trim().length > 0) {
+      chunks.push(createCodeChunk(
+        chunkContent,
+        block.startLine + offset + 1,
+        block.startLine + endOffset,
+        filepath,
+        "block",
+        { symbolName, symbolType: block.type, imports }
+      ));
     }
+    if (endOffset >= blockLines.length) break;
   }
+  return chunks;
+}
+function processSpecialBlock(block, ctx, coveredLines) {
+  for (let i = block.startLine; i <= block.endLine; i++) {
+    coveredLines.add(i);
+  }
+  const symbolName = block.type === "schema" ? extractSchemaName(block.content) : void 0;
+  const blockContentWithoutComments = ctx.linesWithoutComments.slice(block.startLine, block.endLine + 1).join("\n");
+  const imports = extractRenderTags(blockContentWithoutComments);
+  const blockLineCount = block.endLine - block.startLine + 1;
+  const maxBlockSize = ctx.params.chunkSize * 3;
+  if (blockLineCount <= maxBlockSize) {
+    return [createCodeChunk(
+      block.content,
+      block.startLine + 1,
+      block.endLine + 1,
+      ctx.params.filepath,
+      "block",
+      { symbolName, symbolType: block.type, imports }
+    )];
+  }
+  return splitLargeBlock(block, ctx, symbolName, imports);
+}
+function flushTemplateChunk(currentChunk, chunkStartLine, endLine, ctx) {
+  if (currentChunk.length === 0) return null;
+  const chunkContent = currentChunk.join("\n");
+  if (chunkContent.trim().length === 0) return null;
+  const cleanedChunk = ctx.linesWithoutComments.slice(chunkStartLine, endLine).join("\n");
+  const imports = extractRenderTags(cleanedChunk);
+  return createCodeChunk(
+    chunkContent,
+    chunkStartLine + 1,
+    endLine,
+    ctx.params.filepath,
+    "template",
+    { imports }
+  );
+}
+function processTemplateContent(ctx, coveredLines) {
+  const chunks = [];
+  const { lines, params } = ctx;
+  const { chunkSize, chunkOverlap } = params;
   let currentChunk = [];
   let chunkStartLine = 0;
   for (let i = 0; i < lines.length; i++) {
     if (coveredLines.has(i)) {
-      if (currentChunk.length > 0) {
-        const chunkContent = currentChunk.join("\n");
-        if (chunkContent.trim().length > 0) {
-          const cleanedChunk = linesWithoutComments.slice(chunkStartLine, i).join("\n");
-          const imports = extractRenderTags(cleanedChunk);
-          chunks.push({
-            content: chunkContent,
-            metadata: {
-              file: filepath,
-              startLine: chunkStartLine + 1,
-              endLine: i,
-              language: "liquid",
-              type: "template",
-              imports: imports.length > 0 ? imports : void 0
-            }
-          });
-        }
-        currentChunk = [];
-      }
+      const chunk = flushTemplateChunk(currentChunk, chunkStartLine, i, ctx);
+      if (chunk) chunks.push(chunk);
+      currentChunk = [];
       continue;
     }
     if (currentChunk.length === 0) {
@@ -2857,46 +2856,28 @@ function chunkLiquidFile(filepath, content, chunkSize = 75, chunkOverlap = 10) {
     }
     currentChunk.push(lines[i]);
     if (currentChunk.length >= chunkSize) {
-      const chunkContent = currentChunk.join("\n");
-      if (chunkContent.trim().length > 0) {
-        const cleanedChunk = linesWithoutComments.slice(chunkStartLine, i + 1).join("\n");
-        const imports = extractRenderTags(cleanedChunk);
-        chunks.push({
-          content: chunkContent,
-          metadata: {
-            file: filepath,
-            startLine: chunkStartLine + 1,
-            endLine: i + 1,
-            language: "liquid",
-            type: "template",
-            imports: imports.length > 0 ? imports : void 0
-          }
-        });
-      }
+      const chunk = flushTemplateChunk(currentChunk, chunkStartLine, i + 1, ctx);
+      if (chunk) chunks.push(chunk);
       currentChunk = currentChunk.slice(-chunkOverlap);
       chunkStartLine = Math.max(0, i + 1 - chunkOverlap);
     }
   }
-  if (currentChunk.length > 0) {
-    const chunkContent = currentChunk.join("\n");
-    if (chunkContent.trim().length === 0) {
-      return chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
-    }
-    const cleanedChunk = linesWithoutComments.slice(chunkStartLine, lines.length).join("\n");
-    const imports = extractRenderTags(cleanedChunk);
-    chunks.push({
-      content: chunkContent,
-      metadata: {
-        file: filepath,
-        startLine: chunkStartLine + 1,
-        endLine: lines.length,
-        language: "liquid",
-        type: "template",
-        imports: imports.length > 0 ? imports : void 0
-      }
-    });
-  }
-  return chunks.sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+  const finalChunk = flushTemplateChunk(currentChunk, chunkStartLine, lines.length, ctx);
+  if (finalChunk) chunks.push(finalChunk);
+  return chunks;
+}
+function chunkLiquidFile(filepath, content, chunkSize = 75, chunkOverlap = 10) {
+  const contentWithoutComments = removeComments(content);
+  const ctx = {
+    lines: content.split("\n"),
+    linesWithoutComments: contentWithoutComments.split("\n"),
+    params: { filepath, chunkSize, chunkOverlap }
+  };
+  const blocks = findLiquidBlocks(content);
+  const coveredLines = /* @__PURE__ */ new Set();
+  const blockChunks = blocks.flatMap((block) => processSpecialBlock(block, ctx, coveredLines));
+  const templateChunks = processTemplateContent(ctx, coveredLines);
+  return [...blockChunks, ...templateChunks].sort((a, b) => a.metadata.startLine - b.metadata.startLine);
 }
 var init_liquid_chunker = __esm({
   "src/indexer/liquid-chunker.ts"() {
@@ -6150,176 +6131,241 @@ async function initCommand(options = {}) {
     process.exit(1);
   }
 }
-async function createNewConfig(rootDir, options) {
-  showCompactBanner();
-  console.log(chalk3.bold("Initializing Lien...\n"));
-  console.log(chalk3.dim("\u{1F50D} Detecting frameworks in"), chalk3.bold(rootDir));
-  const detections = await detectAllFrameworks(rootDir);
-  let frameworks = [];
-  if (detections.length === 0) {
-    console.log(chalk3.yellow("\n\u26A0\uFE0F  No frameworks detected"));
-    if (!options.yes) {
-      const { useGeneric } = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "useGeneric",
-          message: "Create a generic config (index all supported file types)?",
-          default: true
-        }
-      ]);
-      if (!useGeneric) {
-        console.log(chalk3.dim("Aborted."));
-        return;
-      }
+function createGenericFramework() {
+  return {
+    name: "generic",
+    path: ".",
+    enabled: true,
+    config: {
+      include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
+      exclude: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**",
+        "**/coverage/**",
+        "**/.next/**",
+        "**/.nuxt/**",
+        "**/vendor/**"
+      ]
+    }
+  };
+}
+async function handleNoFrameworksDetected(options) {
+  console.log(chalk3.yellow("\n\u26A0\uFE0F  No frameworks detected"));
+  if (!options.yes) {
+    const { useGeneric } = await inquirer.prompt([{
+      type: "confirm",
+      name: "useGeneric",
+      message: "Create a generic config (index all supported file types)?",
+      default: true
+    }]);
+    if (!useGeneric) {
+      console.log(chalk3.dim("Aborted."));
+      return null;
     }
-    frameworks.push({
-      name: "generic",
-      path: ".",
-      enabled: true,
-      config: {
-        include: ["**/*.{ts,tsx,js,jsx,py,php,go,rs,java,c,cpp,cs}"],
-        exclude: [
-          "**/node_modules/**",
-          "**/dist/**",
-          "**/build/**",
-          "**/.git/**",
-          "**/coverage/**",
-          "**/.next/**",
-          "**/.nuxt/**",
-          "**/vendor/**"
-        ]
-      }
-    });
   } else {
-    console.log(chalk3.green(`
+    console.log(chalk3.dim("Creating generic config (no frameworks detected)..."));
+  }
+  return [createGenericFramework()];
+}
+function displayDetectedFrameworks(detections) {
+  console.log(chalk3.green(`
 \u2713 Found ${detections.length} framework(s):
 `));
-    for (const det of detections) {
-      const pathDisplay = det.path === "." ? "root" : det.path;
-      console.log(chalk3.bold(`  ${det.name}`), chalk3.dim(`(${det.confidence} confidence)`));
-      console.log(chalk3.dim(`    Location: ${pathDisplay}`));
-      if (det.evidence.length > 0) {
-        det.evidence.forEach((e) => {
-          console.log(chalk3.dim(`    \u2022 ${e}`));
-        });
-      }
-      console.log();
-    }
-    if (!options.yes) {
-      const { confirm } = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "confirm",
-          message: "Configure these frameworks?",
-          default: true
-        }
-      ]);
-      if (!confirm) {
-        console.log(chalk3.dim("Aborted."));
-        return;
-      }
-    }
-    for (const det of detections) {
-      const detector = getFrameworkDetector(det.name);
-      if (!detector) {
-        console.warn(chalk3.yellow(`\u26A0\uFE0F  No detector found for ${det.name}, skipping`));
-        continue;
-      }
-      const frameworkConfig = await detector.generateConfig(rootDir, det.path);
-      let shouldCustomize = false;
-      if (!options.yes) {
-        const { customize } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "customize",
-            message: `Customize ${det.name} settings?`,
-            default: false
-          }
-        ]);
-        shouldCustomize = customize;
-      }
-      let finalConfig = frameworkConfig;
-      if (shouldCustomize) {
-        const customized = await promptForCustomization(det.name, frameworkConfig);
-        finalConfig = { ...frameworkConfig, ...customized };
-      } else {
-        const pathDisplay = det.path === "." ? "root" : det.path;
-        console.log(chalk3.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
-      }
-      frameworks.push({
-        name: det.name,
-        path: det.path,
-        enabled: true,
-        config: finalConfig
-      });
-    }
+  for (const det of detections) {
+    const pathDisplay = det.path === "." ? "root" : det.path;
+    console.log(chalk3.bold(`  ${det.name}`), chalk3.dim(`(${det.confidence} confidence)`));
+    console.log(chalk3.dim(`    Location: ${pathDisplay}`));
+    if (det.evidence.length > 0) {
+      det.evidence.forEach((e) => console.log(chalk3.dim(`    \u2022 ${e}`)));
+    }
+    console.log();
+  }
+}
+async function confirmFrameworkConfiguration(options) {
+  if (options.yes) return true;
+  const { confirm } = await inquirer.prompt([{
+    type: "confirm",
+    name: "confirm",
+    message: "Configure these frameworks?",
+    default: true
+  }]);
+  return confirm;
+}
+async function generateSingleFrameworkConfig(det, rootDir, options) {
+  const detector = getFrameworkDetector(det.name);
+  if (!detector) {
+    console.warn(chalk3.yellow(`\u26A0\uFE0F  No detector found for ${det.name}, skipping`));
+    return null;
   }
+  const frameworkConfig = await detector.generateConfig(rootDir, det.path);
+  let finalConfig = frameworkConfig;
+  const pathDisplay = det.path === "." ? "root" : det.path;
   if (!options.yes) {
-    const { installCursorRules } = await inquirer.prompt([
-      {
-        type: "confirm",
-        name: "installCursorRules",
-        message: "Install recommended Cursor rules?",
-        default: true
-      }
-    ]);
-    if (installCursorRules) {
+    const { customize } = await inquirer.prompt([{
+      type: "confirm",
+      name: "customize",
+      message: `Customize ${det.name} settings?`,
+      default: false
+    }]);
+    if (customize) {
+      const customized = await promptForCustomization(det.name, frameworkConfig);
+      finalConfig = { ...frameworkConfig, ...customized };
+    } else {
+      console.log(chalk3.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
+    }
+  } else {
+    console.log(chalk3.dim(`  \u2192 Using defaults for ${det.name} at ${pathDisplay}`));
+  }
+  return {
+    name: det.name,
+    path: det.path,
+    enabled: true,
+    config: finalConfig
+  };
+}
+async function handleFrameworksDetected(detections, rootDir, options) {
+  displayDetectedFrameworks(detections);
+  if (!await confirmFrameworkConfiguration(options)) {
+    console.log(chalk3.dim("Aborted."));
+    return null;
+  }
+  const frameworks = [];
+  for (const det of detections) {
+    const framework = await generateSingleFrameworkConfig(det, rootDir, options);
+    if (framework) frameworks.push(framework);
+  }
+  if (frameworks.length === 0) {
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  No framework configs could be generated"));
+    return null;
+  }
+  return frameworks;
+}
+async function getPathType(filepath) {
+  try {
+    const stats = await fs8.stat(filepath);
+    if (stats.isDirectory()) return "directory";
+    if (stats.isFile()) return "file";
+    return "other";
+  } catch {
+    return "none";
+  }
+}
+async function convertRulesFileToDirectory(rulesPath, templatePath) {
+  const existingRules = await fs8.readFile(rulesPath, "utf-8");
+  const parentDir = path8.dirname(rulesPath);
+  const baseName = path8.basename(rulesPath);
+  const tempDir = await fs8.mkdtemp(path8.join(parentDir, baseName + "_tmp_"));
+  const backupPath = rulesPath + ".backup";
+  try {
+    await fs8.writeFile(path8.join(tempDir, "project.mdc"), existingRules);
+    await fs8.copyFile(templatePath, path8.join(tempDir, "lien.mdc"));
+    try {
+      await fs8.unlink(backupPath);
+    } catch {
+    }
+    await fs8.rename(rulesPath, backupPath);
+    try {
+      await fs8.rename(tempDir, rulesPath);
       try {
-        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 fs8.stat(rulesPath);
-          isDirectory = stats.isDirectory();
-          isFile = stats.isFile();
-        } catch {
-        }
-        if (isDirectory) {
-          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([
-            {
-              type: "confirm",
-              name: "convertToDir",
-              message: "Existing .cursor/rules file found. Convert to directory and preserve your rules?",
-              default: true
-            }
-          ]);
-          if (convertToDir) {
-            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"));
-          } else {
-            console.log(chalk3.dim("Skipped Cursor rules installation (preserving existing file)"));
-          }
-        } else {
-          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) {
-        console.log(chalk3.yellow("\u26A0\uFE0F  Could not install Cursor rules"));
-        console.log(chalk3.dim(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
-        console.log(chalk3.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
+        await fs8.unlink(backupPath);
+      } catch {
+        console.log(chalk3.yellow("\u26A0\uFE0F  Could not remove backup file, but conversion succeeded"));
+        console.log(chalk3.dim(`Backup file: ${backupPath}`));
       }
+    } catch (renameErr) {
+      try {
+        await fs8.rename(backupPath, rulesPath);
+      } catch (restoreErr) {
+        console.log(chalk3.red("\u274C Failed to restore original .cursor/rules from backup after failed conversion."));
+        console.log(chalk3.red(`   - Original error: ${renameErr instanceof Error ? renameErr.message : renameErr}`));
+        console.log(chalk3.red(`   - Restore error: ${restoreErr instanceof Error ? restoreErr.message : restoreErr}`));
+        console.log(chalk3.red(`   - Backup file location: ${backupPath}`));
+        throw new Error("Failed to convert .cursor/rules to directory and failed to restore from backup. Manual recovery needed.");
+      }
+      throw renameErr;
+    }
+    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"));
+  } catch (err) {
+    try {
+      await fs8.rm(tempDir, { recursive: true, force: true });
+    } catch {
     }
+    throw err;
+  }
+}
+async function handleExistingRulesDirectory(rulesPath, templatePath) {
+  const targetPath = path8.join(rulesPath, "lien.mdc");
+  try {
+    await fs8.access(targetPath);
+    console.log(chalk3.dim("lien.mdc already exists in .cursor/rules/, skipping..."));
+    return;
+  } catch {
+  }
+  await fs8.copyFile(templatePath, targetPath);
+  console.log(chalk3.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
+}
+async function handleExistingRulesFile(rulesPath, templatePath, options) {
+  if (options.yes) {
+    console.log(chalk3.dim("Skipped Cursor rules installation (preserving existing .cursor/rules file)"));
+    return;
   }
-  const config = {
-    ...defaultConfig,
-    frameworks
+  const { convertToDir } = await inquirer.prompt([{
+    type: "confirm",
+    name: "convertToDir",
+    message: "Existing .cursor/rules file found. Convert to directory and preserve your rules?",
+    default: true
+  }]);
+  if (convertToDir) {
+    await convertRulesFileToDirectory(rulesPath, templatePath);
+  } else {
+    console.log(chalk3.dim("Skipped Cursor rules installation (preserving existing file)"));
+  }
+}
+async function handleInvalidRulesPath() {
+  console.log(chalk3.yellow("\u26A0\uFE0F  .cursor/rules exists but is not a regular file or directory"));
+  console.log(chalk3.dim("Skipped Cursor rules installation"));
+}
+async function handleFreshRulesInstall(rulesPath, templatePath) {
+  await fs8.mkdir(rulesPath, { recursive: true });
+  await fs8.copyFile(templatePath, path8.join(rulesPath, "lien.mdc"));
+  console.log(chalk3.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
+}
+async function installCursorRulesFiles(rootDir, options) {
+  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");
+  const pathType = await getPathType(rulesPath);
+  const handlers = {
+    directory: () => handleExistingRulesDirectory(rulesPath, templatePath),
+    file: () => handleExistingRulesFile(rulesPath, templatePath, options),
+    other: () => handleInvalidRulesPath(),
+    none: () => handleFreshRulesInstall(rulesPath, templatePath)
   };
+  await handlers[pathType]();
+}
+async function promptAndInstallCursorRules(rootDir, options) {
+  const shouldInstall = options.yes || (await inquirer.prompt([{
+    type: "confirm",
+    name: "installCursorRules",
+    message: "Install recommended Cursor rules?",
+    default: true
+  }])).installCursorRules;
+  if (!shouldInstall) return;
+  try {
+    await installCursorRulesFiles(rootDir, options);
+  } catch (error) {
+    console.log(chalk3.yellow("\u26A0\uFE0F  Could not install Cursor rules"));
+    console.log(chalk3.dim(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    console.log(chalk3.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
+  }
+}
+async function writeConfigAndShowSuccess(rootDir, frameworks) {
+  const config = { ...defaultConfig, frameworks };
   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"));
@@ -6329,6 +6375,16 @@ async function createNewConfig(rootDir, options) {
   console.log(chalk3.dim("  2. Run"), chalk3.bold("lien serve"), chalk3.dim("to start the MCP server"));
   console.log(chalk3.dim("  3. Configure Cursor to use the MCP server (see README.md)"));
 }
+async function createNewConfig(rootDir, options) {
+  showCompactBanner();
+  console.log(chalk3.bold("Initializing Lien...\n"));
+  console.log(chalk3.dim("\u{1F50D} Detecting frameworks in"), chalk3.bold(rootDir));
+  const detections = await detectAllFrameworks(rootDir);
+  const frameworks = detections.length === 0 ? await handleNoFrameworksDetected(options) : await handleFrameworksDetected(detections, rootDir, options);
+  if (!frameworks) return;
+  await promptAndInstallCursorRules(rootDir, options);
+  await writeConfigAndShowSuccess(rootDir, frameworks);
+}
 async function promptForCustomization(frameworkName, config) {
   console.log(chalk3.bold(`
 Customizing ${frameworkName} settings:`));
@@ -6480,7 +6536,7 @@ async function indexCommand(options) {
 // src/cli/serve.ts
 import chalk7 from "chalk";
 import fs20 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 
 // src/mcp/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -6793,8 +6849,8 @@ async function handleFindSimilar(args, ctx) {
 }
 
 // src/mcp/utils/path-matching.ts
-function normalizePath(path23, workspaceRoot) {
-  let normalized = path23.replace(/['"]/g, "").trim().replace(/\\/g, "/");
+function normalizePath(path24, workspaceRoot) {
+  let normalized = path24.replace(/['"]/g, "").trim().replace(/\\/g, "/");
   normalized = normalized.replace(/\.(ts|tsx|js|jsx)$/, "");
   if (normalized.startsWith(workspaceRoot + "/")) {
     normalized = normalized.substring(workspaceRoot.length + 1);
@@ -6890,10 +6946,10 @@ async function handleGetFilesContext(args, ctx) {
         log(`Scanned ${SCAN_LIMIT} chunks (limit reached). Test associations may be incomplete for large codebases.`, "warning");
       }
       const pathCache = /* @__PURE__ */ new Map();
-      const normalizePathCached = (path23) => {
-        if (pathCache.has(path23)) return pathCache.get(path23);
-        const normalized = normalizePath(path23, workspaceRoot);
-        pathCache.set(path23, normalized);
+      const normalizePathCached = (path24) => {
+        if (pathCache.has(path24)) return pathCache.get(path24);
+        const normalized = normalizePath(path24, workspaceRoot);
+        pathCache.set(path24, normalized);
         return normalized;
       };
       const testAssociationsMap = filepaths.map((filepath) => {
@@ -7134,9 +7190,9 @@ async function handleGetDependents(args, ctx) {
       log(`Scanning ${allChunks.length} chunks for imports...`);
       const workspaceRoot = process.cwd().replace(/\\/g, "/");
       const pathCache = /* @__PURE__ */ new Map();
-      const normalizePathCached = (path23) => {
-        if (!pathCache.has(path23)) pathCache.set(path23, normalizePath(path23, workspaceRoot));
-        return pathCache.get(path23);
+      const normalizePathCached = (path24) => {
+        if (!pathCache.has(path24)) pathCache.set(path24, normalizePath(path24, workspaceRoot));
+        return pathCache.get(path24);
       };
       const importIndex = buildImportIndex(allChunks, normalizePathCached);
       const normalizedTarget = normalizePathCached(validatedArgs.filepath);
@@ -7202,11 +7258,11 @@ var COMPLEXITY_THRESHOLDS2 = {
 };
 function createPathNormalizer(workspaceRoot) {
   const cache = /* @__PURE__ */ new Map();
-  return (path23) => {
-    const cached = cache.get(path23);
+  return (path24) => {
+    const cached = cache.get(path24);
     if (cached !== void 0) return cached;
-    const normalized = normalizePath(path23, workspaceRoot);
-    cache.set(path23, normalized);
+    const normalized = normalizePath(path24, workspaceRoot);
+    cache.set(path24, normalized);
     return normalized;
   };
 }
@@ -7717,6 +7773,7 @@ init_utils();
 // src/watcher/index.ts
 init_schema();
 import chokidar from "chokidar";
+import path21 from "path";
 var FileWatcher = class {
   watcher = null;
   debounceTimers = /* @__PURE__ */ new Map();
@@ -7755,9 +7812,12 @@ var FileWatcher = class {
       persistent: true,
       ignoreInitial: true,
       // Don't trigger for existing files
+      // Handle atomic saves from modern editors (VS Code, Sublime, etc.)
+      // Editors write to temp file then rename - without this, we get unlink+add instead of change
+      atomic: true,
       awaitWriteFinish: {
-        stabilityThreshold: 500,
-        // Wait 500ms for file to stop changing
+        stabilityThreshold: 300,
+        // Reduced from 500ms for faster detection
         pollInterval: 100
       },
       // Performance optimizations
@@ -7786,7 +7846,7 @@ var FileWatcher = class {
     const timer = setTimeout(() => {
       this.debounceTimers.delete(filepath);
       if (this.onChangeHandler) {
-        const absolutePath = filepath.startsWith("/") ? filepath : `${this.rootDir}/${filepath}`;
+        const absolutePath = path21.isAbsolute(filepath) ? filepath : path21.join(this.rootDir, filepath);
         try {
           const result = this.onChangeHandler({
             type,
@@ -8061,7 +8121,7 @@ async function startMCPServer(options) {
 
 // src/cli/serve.ts
 async function serveCommand(options) {
-  const rootDir = options.root ? path21.resolve(options.root) : process.cwd();
+  const rootDir = options.root ? path22.resolve(options.root) : process.cwd();
   try {
     if (options.root) {
       try {
@@ -8109,7 +8169,7 @@ init_lancedb();
 init_service();
 import chalk9 from "chalk";
 import fs21 from "fs";
-import path22 from "path";
+import path23 from "path";
 
 // src/insights/formatters/text.ts
 import chalk8 from "chalk";
@@ -8384,7 +8444,7 @@ function validateFormat(format) {
 function validateFilesExist(files, rootDir) {
   if (!files || files.length === 0) return;
   const missingFiles = files.filter((file) => {
-    const fullPath = path22.isAbsolute(file) ? file : path22.join(rootDir, file);
+    const fullPath = path23.isAbsolute(file) ? file : path23.join(rootDir, file);
     return !fs21.existsSync(fullPath);
   });
   if (missingFiles.length > 0) {