@liendev/lien 0.22.0 → 0.24.0

package/README.md

@@ -26,15 +26,10 @@ Lien connects AI coding assistants like Cursor to your codebase through the Mode
 ## Quick Start
 
 ```bash
-# Install
+# 1. Install
 npm install -g @liendev/lien
 
-# Setup in your project
-cd /path/to/your/project
-lien init
-lien index
-
-# Configure Cursor - create .cursor/mcp.json
+# 2. Add to your project - create .cursor/mcp.json
 {
   "mcpServers": {
     "lien": {
@@ -44,9 +39,11 @@ lien index
   }
 }
 
-# Restart Cursor and start asking questions!
+# 3. Restart Cursor and start asking questions!
 ```
 
+That's it—zero configuration needed. Lien auto-detects your project and indexes on first use.
+
 **👉 [Full installation guide](https://lien.dev/guide/installation)**
 
 ### Qdrant Backend (Cross-Repo Search)

package/dist/index.js

@@ -3591,15 +3591,13 @@ var require_dist = __commonJS({
 // src/cli/index.ts
 import { Command } from "commander";
 import { createRequire as createRequire3 } from "module";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname3, join as join3 } from "path";
 
 // src/cli/init.ts
 import fs from "fs/promises";
 import path from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk2 from "chalk";
-import inquirer from "inquirer";
 
 // src/utils/banner.ts
 import figlet from "figlet";
@@ -3661,8 +3659,6 @@ function showCompactBanner() {
 }
 
 // src/cli/init.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
 async function initCommand(options = {}) {
   showCompactBanner();
   console.log(chalk2.bold("\nLien Initialization\n"));
@@ -3695,129 +3691,6 @@ async function initCommand(options = {}) {
     console.log(chalk2.dim("  You can safely delete it."));
   } catch {
   }
-  await promptAndInstallCursorRules(rootDir, options);
-}
-async function getPathType(filepath) {
-  try {
-    const stats = await fs.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 fs.readFile(rulesPath, "utf-8");
-  const parentDir = path.dirname(rulesPath);
-  const baseName = path.basename(rulesPath);
-  const tempDir = await fs.mkdtemp(path.join(parentDir, baseName + "_tmp_"));
-  const backupPath = rulesPath + ".backup";
-  try {
-    await fs.writeFile(path.join(tempDir, "project.mdc"), existingRules);
-    await fs.copyFile(templatePath, path.join(tempDir, "lien.mdc"));
-    try {
-      await fs.unlink(backupPath);
-    } catch {
-    }
-    await fs.rename(rulesPath, backupPath);
-    try {
-      await fs.rename(tempDir, rulesPath);
-      try {
-        await fs.unlink(backupPath);
-      } catch {
-        console.log(chalk2.yellow("\u26A0\uFE0F  Could not remove backup file, but conversion succeeded"));
-        console.log(chalk2.dim(`Backup file: ${backupPath}`));
-      }
-    } catch (renameErr) {
-      try {
-        await fs.rename(backupPath, rulesPath);
-      } catch (restoreErr) {
-        console.log(chalk2.red("\u274C Failed to restore original .cursor/rules from backup after failed conversion."));
-        console.log(chalk2.red(`   - Original error: ${renameErr instanceof Error ? renameErr.message : renameErr}`));
-        console.log(chalk2.red(`   - Restore error: ${restoreErr instanceof Error ? restoreErr.message : restoreErr}`));
-        console.log(chalk2.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(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"));
-  } catch (err) {
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch {
-    }
-    throw err;
-  }
-}
-async function handleExistingRulesDirectory(rulesPath, templatePath) {
-  const targetPath = path.join(rulesPath, "lien.mdc");
-  try {
-    await fs.access(targetPath);
-    console.log(chalk2.dim("lien.mdc already exists in .cursor/rules/, skipping..."));
-    return;
-  } catch {
-  }
-  await fs.copyFile(templatePath, targetPath);
-  console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
-}
-async function handleExistingRulesFile(rulesPath, templatePath, options) {
-  if (options.yes) {
-    console.log(chalk2.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(chalk2.dim("Skipped Cursor rules installation (preserving existing file)"));
-  }
-}
-async function handleInvalidRulesPath() {
-  console.log(chalk2.yellow("\u26A0\uFE0F  .cursor/rules exists but is not a regular file or directory"));
-  console.log(chalk2.dim("Skipped Cursor rules installation"));
-}
-async function handleFreshRulesInstall(rulesPath, templatePath) {
-  await fs.mkdir(rulesPath, { recursive: true });
-  await fs.copyFile(templatePath, path.join(rulesPath, "lien.mdc"));
-  console.log(chalk2.green("\u2713 Installed Cursor rules as .cursor/rules/lien.mdc"));
-}
-async function installCursorRulesFiles(rootDir, options) {
-  const cursorRulesDir = path.join(rootDir, ".cursor");
-  await fs.mkdir(cursorRulesDir, { recursive: true });
-  const templatePath = path.join(__dirname2, "../CURSOR_RULES_TEMPLATE.md");
-  const rulesPath = path.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(chalk2.yellow("\u26A0\uFE0F  Could not install Cursor rules"));
-    console.log(chalk2.dim(`Error: ${error instanceof Error ? error.message : "Unknown error"}`));
-    console.log(chalk2.dim("You can manually copy CURSOR_RULES_TEMPLATE.md to .cursor/rules/lien.mdc"));
-  }
 }
 
 // src/cli/status.ts
@@ -3984,98 +3857,123 @@ function getModelLoadingMessage() {
 }
 
 // src/cli/index-cmd.ts
+async function clearExistingIndex() {
+  const { VectorDB: VectorDB2 } = await import("@liendev/core");
+  const { ManifestManager: ManifestManager2 } = await import("@liendev/core");
+  console.log(chalk4.yellow("Clearing existing index and manifest..."));
+  const vectorDB = new VectorDB2(process.cwd());
+  await vectorDB.initialize();
+  await vectorDB.clear();
+  const manifest = new ManifestManager2(vectorDB.dbPath);
+  await manifest.clear();
+  console.log(chalk4.green("\u2713 Index and manifest cleared\n"));
+}
+function createProgressTracker() {
+  return {
+    current: {
+      phase: "initializing",
+      message: "Starting...",
+      filesTotal: 0,
+      filesProcessed: 0
+    },
+    wittyMessage: getIndexingMessage(),
+    lastUpdateTime: 0,
+    updateCount: 0,
+    completedViaProgress: false
+  };
+}
+function updateSpinner(spinner, tracker, forceUpdate = false) {
+  const now = Date.now();
+  tracker.updateCount++;
+  const shouldThrottle = tracker.updateCount > 20;
+  const throttleMs = 50;
+  if (!forceUpdate && shouldThrottle && now - tracker.lastUpdateTime < throttleMs) {
+    return;
+  }
+  tracker.lastUpdateTime = now;
+  const { current, wittyMessage } = tracker;
+  const text = current.filesTotal && current.filesProcessed !== void 0 ? `${current.filesProcessed}/${current.filesTotal} files | ${wittyMessage}` : wittyMessage;
+  spinner.text = text;
+  setImmediate(() => spinner.render());
+}
+function updateWittyMessage(tracker) {
+  const { current } = tracker;
+  if (current.phase === "embedding" || current.phase === "indexing") {
+    tracker.wittyMessage = getIndexingMessage();
+  } else if (current.phase === "initializing") {
+    tracker.wittyMessage = getModelLoadingMessage();
+  }
+}
+function startMessageRotation(spinner, tracker) {
+  tracker.messageRotationInterval = setInterval(() => {
+    updateWittyMessage(tracker);
+    updateSpinner(spinner, tracker, true);
+  }, 8e3);
+}
+function stopMessageRotation(tracker) {
+  if (tracker.messageRotationInterval) {
+    clearInterval(tracker.messageRotationInterval);
+    tracker.messageRotationInterval = void 0;
+  }
+}
+function createProgressCallback(spinner, tracker) {
+  return (progress) => {
+    tracker.current = progress;
+    if (progress.phase === "initializing" && !tracker.messageRotationInterval) {
+      tracker.wittyMessage = getModelLoadingMessage();
+    } else if (progress.phase === "embedding") {
+      tracker.wittyMessage = getEmbeddingMessage();
+    } else if (progress.phase === "indexing") {
+      tracker.wittyMessage = getIndexingMessage();
+    }
+    if (progress.phase === "complete") {
+      tracker.completedViaProgress = true;
+      stopMessageRotation(tracker);
+      let message = progress.message;
+      if (progress.filesTotal && progress.filesProcessed !== void 0) {
+        message = `${message} (${progress.filesProcessed}/${progress.filesTotal})`;
+      }
+      spinner.succeed(chalk4.green(message));
+    } else {
+      updateSpinner(spinner, tracker);
+    }
+  };
+}
+function displayFinalResult(spinner, tracker, result) {
+  if (!tracker.completedViaProgress) {
+    if (result.filesIndexed === 0) {
+      spinner.succeed(chalk4.green("Index is up to date - no changes detected"));
+    } else {
+      spinner.succeed(chalk4.green(`Indexed ${result.filesIndexed} files, ${result.chunksCreated} chunks`));
+    }
+  }
+}
 async function indexCommand(options) {
   showCompactBanner();
   try {
     if (options.force) {
-      const { VectorDB: VectorDB2 } = await import("@liendev/core");
-      const { ManifestManager: ManifestManager2 } = await import("@liendev/core");
-      console.log(chalk4.yellow("Clearing existing index and manifest..."));
-      const vectorDB = new VectorDB2(process.cwd());
-      await vectorDB.initialize();
-      await vectorDB.clear();
-      const manifest = new ManifestManager2(vectorDB.dbPath);
-      await manifest.clear();
-      console.log(chalk4.green("\u2713 Index and manifest cleared\n"));
+      await clearExistingIndex();
     }
     const spinner = ora({
       text: "Starting indexing...",
       interval: 30
       // Faster refresh rate for smoother progress
     }).start();
-    let completedViaProgress = false;
-    let wittyMessage = getIndexingMessage();
-    let messageRotationInterval;
-    let lastUpdateTime = 0;
-    let updateCount = 0;
-    let currentProgress = {
-      phase: "initializing",
-      message: "Starting...",
-      filesTotal: 0,
-      filesProcessed: 0
-    };
-    const updateSpinner = (forceUpdate = false) => {
-      const now = Date.now();
-      updateCount++;
-      const shouldThrottle = updateCount > 20;
-      const throttleMs = 50;
-      if (!forceUpdate && shouldThrottle && now - lastUpdateTime < throttleMs) {
-        return;
-      }
-      lastUpdateTime = now;
-      let text = "";
-      if (currentProgress.filesTotal && currentProgress.filesProcessed !== void 0) {
-        text = `${currentProgress.filesProcessed}/${currentProgress.filesTotal} files | ${wittyMessage}`;
-      } else {
-        text = wittyMessage;
-      }
-      spinner.text = text;
-      setImmediate(() => {
-        spinner.render();
-      });
-    };
-    messageRotationInterval = setInterval(() => {
-      if (currentProgress.phase === "embedding" || currentProgress.phase === "indexing") {
-        wittyMessage = getIndexingMessage();
-      } else if (currentProgress.phase === "initializing") {
-        wittyMessage = getModelLoadingMessage();
-      }
-      updateSpinner(true);
-    }, 8e3);
+    const tracker = createProgressTracker();
+    startMessageRotation(spinner, tracker);
     const result = await indexCodebase({
       rootDir: process.cwd(),
       verbose: options.verbose || false,
       force: options.force || false,
-      onProgress: (progress) => {
-        currentProgress = progress;
-        if (progress.phase === "initializing" && !messageRotationInterval) {
-          wittyMessage = getModelLoadingMessage();
-        } else if (progress.phase === "embedding") {
-          wittyMessage = getEmbeddingMessage();
-        } else if (progress.phase === "indexing") {
-          wittyMessage = getIndexingMessage();
-        }
-        if (progress.phase === "complete") {
-          completedViaProgress = true;
-          if (messageRotationInterval) clearInterval(messageRotationInterval);
-          let message = progress.message;
-          if (progress.filesTotal && progress.filesProcessed !== void 0) {
-            message = `${message} (${progress.filesProcessed}/${progress.filesTotal})`;
-          }
-          spinner.succeed(chalk4.green(message));
-        } else {
-          updateSpinner();
-        }
-      }
+      onProgress: createProgressCallback(spinner, tracker)
     });
-    if (messageRotationInterval) clearInterval(messageRotationInterval);
-    if (!completedViaProgress) {
-      if (result.filesIndexed === 0) {
-        spinner.succeed(chalk4.green("Index is up to date - no changes detected"));
-      } else {
-        spinner.succeed(chalk4.green(`Indexed ${result.filesIndexed} files, ${result.chunksCreated} chunks`));
-      }
+    stopMessageRotation(tracker);
+    if (!result.success && result.error) {
+      spinner.fail(chalk4.red("Indexing failed"));
+      console.error(chalk4.red("\n" + result.error));
+      process.exit(1);
     }
+    displayFinalResult(spinner, tracker, result);
     if (options.watch) {
       console.log(chalk4.yellow("\n\u26A0\uFE0F  Watch mode not yet implemented"));
     }
@@ -4094,7 +3992,7 @@ import path4 from "path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createRequire as createRequire2 } from "module";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2, join as join2 } from "path";
 import {
   LocalEmbeddings,
@@ -8462,7 +8360,7 @@ var tools = [
   toMCPToolSchema(
     SemanticSearchSchema,
     "semantic_search",
-    `Search codebase by MEANING, not text. USE THIS INSTEAD OF grep/ripgrep for finding implementations, features, or understanding how code works.
+    `Search codebase by MEANING, not text. Complements grep - use this for discovery and understanding, grep for exact matches.
 
 Examples:
 - "Where is authentication handled?" \u2192 semantic_search({ query: "handles user authentication" })
@@ -8913,6 +8811,25 @@ async function handleGetFilesContext(args, ctx) {
 }
 
 // src/mcp/handlers/list-functions.ts
+async function performContentScan(vectorDB, args, log) {
+  log("Falling back to content scan...");
+  let results = await vectorDB.scanWithFilter({
+    language: args.language,
+    limit: 200
+    // Fetch more, we'll filter by symbolName
+  });
+  if (args.pattern) {
+    const regex = new RegExp(args.pattern, "i");
+    results = results.filter((r) => {
+      const symbolName = r.metadata?.symbolName;
+      return symbolName && regex.test(symbolName);
+    });
+  }
+  return {
+    results: results.slice(0, 50),
+    method: "content"
+  };
+}
 async function handleListFunctions(args, ctx) {
   const { vectorDB, log, checkAndReconnect, getIndexMetadata } = ctx;
   return await wrapToolHandler(
@@ -8920,38 +8837,29 @@ async function handleListFunctions(args, ctx) {
     async (validatedArgs) => {
       log("Listing functions with symbol metadata...");
       await checkAndReconnect();
-      let results;
-      let usedMethod = "symbols";
+      let queryResult;
       try {
-        results = await vectorDB.querySymbols({
+        const results = await vectorDB.querySymbols({
           language: validatedArgs.language,
           pattern: validatedArgs.pattern,
           limit: 50
         });
         if (results.length === 0 && (validatedArgs.language || validatedArgs.pattern)) {
           log("No symbol results, falling back to content scan...");
-          results = await vectorDB.scanWithFilter({
-            language: validatedArgs.language,
-            pattern: validatedArgs.pattern,
-            limit: 50
-          });
-          usedMethod = "content";
+          queryResult = await performContentScan(vectorDB, validatedArgs, log);
+        } else {
+          queryResult = { results, method: "symbols" };
         }
       } catch (error) {
-        log(`Symbol query failed, falling back to content scan: ${error}`);
-        results = await vectorDB.scanWithFilter({
-          language: validatedArgs.language,
-          pattern: validatedArgs.pattern,
-          limit: 50
-        });
-        usedMethod = "content";
+        log(`Symbol query failed: ${error}`);
+        queryResult = await performContentScan(vectorDB, validatedArgs, log);
       }
-      log(`Found ${results.length} matches using ${usedMethod} method`);
+      log(`Found ${queryResult.results.length} matches using ${queryResult.method} method`);
       return {
         indexInfo: getIndexMetadata(),
-        method: usedMethod,
-        results,
-        note: usedMethod === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
+        method: queryResult.method,
+        results: queryResult.results,
+        note: queryResult.method === "content" ? 'Using content search. Run "lien reindex" to enable faster symbol-based queries.' : void 0
       };
     }
   )(args);
@@ -9352,14 +9260,14 @@ function registerMCPHandlers(server, toolContext, log) {
 }
 
 // src/mcp/server.ts
-var __filename3 = fileURLToPath3(import.meta.url);
-var __dirname3 = dirname2(__filename3);
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
 var require3 = createRequire2(import.meta.url);
 var packageJson2;
 try {
-  packageJson2 = require3(join2(__dirname3, "../package.json"));
+  packageJson2 = require3(join2(__dirname2, "../package.json"));
 } catch {
-  packageJson2 = require3(join2(__dirname3, "../../package.json"));
+  packageJson2 = require3(join2(__dirname2, "../../package.json"));
 }
 async function initializeDatabase(rootDir, log) {
   const embeddings = new LocalEmbeddings();
@@ -9694,14 +9602,14 @@ async function complexityCommand(options) {
 }
 
 // src/cli/index.ts
-var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname3(__filename4);
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname3(__filename3);
 var require4 = createRequire3(import.meta.url);
 var packageJson3;
 try {
-  packageJson3 = require4(join3(__dirname4, "../package.json"));
+  packageJson3 = require4(join3(__dirname3, "../package.json"));
 } catch {
-  packageJson3 = require4(join3(__dirname4, "../../package.json"));
+  packageJson3 = require4(join3(__dirname3, "../../package.json"));
 }
 var program = new Command();
 program.name("lien").description("Local semantic code search for AI assistants via MCP").version(packageJson3.version);