@liendev/lien 0.19.3 → 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;
   }
-  const config = {
-    ...defaultConfig,
-    frameworks
+}
+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 { 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:`));