@liendev/lien 0.39.0 → 0.41.0

package/dist/index.js

@@ -3828,13 +3828,11 @@ import {
   getCurrentBranch,
   getCurrentCommit,
   readVersionFile,
-  extractRepoId,
   DEFAULT_CONCURRENCY,
   DEFAULT_EMBEDDING_BATCH_SIZE,
-  DEFAULT_CHUNK_SIZE,
-  DEFAULT_CHUNK_OVERLAP,
   DEFAULT_GIT_POLL_INTERVAL_MS
 } from "@liendev/core";
+import { extractRepoId, DEFAULT_CHUNK_SIZE, DEFAULT_CHUNK_OVERLAP } from "@liendev/parser";
 var VALID_FORMATS = ["text", "json"];
 async function getFileStats(filePath) {
   try {
@@ -4251,7 +4249,7 @@ import {
   detectEcosystems,
   getEcosystemExcludePatterns,
   ALWAYS_IGNORE_PATTERNS
-} from "@liendev/core";
+} from "@liendev/parser";
 var FileWatcher = class {
   watcher = null;
   rootDir;
@@ -5142,8 +5140,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path10, errorMaps, issueData } = params;
-  const fullPath = [...path10, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5259,11 +5257,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path10, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path10;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -9392,7 +9390,7 @@ import {
   getCanonicalPath,
   isTestFile,
   MAX_CHUNKS_PER_FILE
-} from "@liendev/core";
+} from "@liendev/parser";
 var SCAN_LIMIT = 1e4;
 async function searchFileChunks(filepaths, ctx) {
   const { vectorDB, workspaceRoot } = ctx;
@@ -9437,10 +9435,10 @@ async function findRelatedChunks(filepaths, fileChunksMap, ctx) {
 }
 function createPathCache(workspaceRoot) {
   const cache = /* @__PURE__ */ new Map();
-  const normalize = (path10) => {
-    if (cache.has(path10)) return cache.get(path10);
-    const normalized = normalizePath(path10, workspaceRoot);
-    cache.set(path10, normalized);
+  const normalize = (path11) => {
+    if (cache.has(path11)) return cache.get(path11);
+    const normalized = normalizePath(path11, workspaceRoot);
+    cache.set(path11, normalized);
     return normalized;
   };
   return { normalize, cache };
@@ -9648,7 +9646,7 @@ import {
   matchesFile as matchesFile2,
   getCanonicalPath as getCanonicalPath2,
   isTestFile as isTestFile2
-} from "@liendev/core";
+} from "@liendev/parser";
 var COMPLEXITY_THRESHOLDS = {
   HIGH_COMPLEXITY_DEPENDENT: 10,
   // Individual file is complex
@@ -9815,11 +9813,11 @@ async function scanChunksPaginated(vectorDB, crossRepo, log, normalizePathCached
 function createPathNormalizer() {
   const workspaceRoot = process.cwd().replace(/\\/g, "/");
   const cache = /* @__PURE__ */ new Map();
-  return (path10) => {
-    if (!cache.has(path10)) {
-      cache.set(path10, normalizePath2(path10, workspaceRoot));
+  return (path11) => {
+    if (!cache.has(path11)) {
+      cache.set(path11, normalizePath2(path11, workspaceRoot));
     }
-    return cache.get(path10);
+    return cache.get(path11);
   };
 }
 function groupChunksByFile(chunks) {
@@ -10566,9 +10564,9 @@ import {
   indexMultipleFiles as indexMultipleFiles2,
   isGitAvailable,
   isGitRepo as isGitRepo2,
-  DEFAULT_GIT_POLL_INTERVAL_MS as DEFAULT_GIT_POLL_INTERVAL_MS2,
-  createGitignoreFilter as createGitignoreFilter2
+  DEFAULT_GIT_POLL_INTERVAL_MS as DEFAULT_GIT_POLL_INTERVAL_MS2
 } from "@liendev/core";
+import { createGitignoreFilter as createGitignoreFilter2 } from "@liendev/parser";
 
 // src/mcp/file-change-handler.ts
 import fs3 from "fs/promises";
@@ -10576,10 +10574,9 @@ import {
   indexMultipleFiles,
   indexSingleFile,
   ManifestManager,
-  computeContentHash,
-  normalizeToRelativePath as normalizeToRelativePath2,
-  createGitignoreFilter
+  normalizeToRelativePath as normalizeToRelativePath2
 } from "@liendev/core";
+import { computeContentHash, createGitignoreFilter } from "@liendev/parser";
 async function handleFileDeletion(filepath, vectorDB, manifest, log) {
   log(`\u{1F5D1}\uFE0F  File deleted: ${filepath}`);
   try {
@@ -11421,12 +11418,275 @@ async function complexityCommand(options) {
   }
 }
 
-// src/cli/config.ts
+// src/cli/review.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
 import chalk8 from "chalk";
+import ora3 from "ora";
+import fs7 from "fs";
 import path9 from "path";
+import {
+  performChunkOnlyIndex,
+  analyzeComplexityFromChunks
+} from "@liendev/parser";
+import {
+  ReviewEngine,
+  loadConfig,
+  loadPlugins,
+  resolveLLMApiKey,
+  getPluginConfig,
+  OpenRouterLLMClient,
+  TerminalAdapter,
+  SARIFAdapter,
+  filterAnalyzableFiles,
+  consoleLogger
+} from "@liendev/review";
+var execFileAsync = promisify(execFile);
+var VALID_FAIL_ON2 = ["error", "warning"];
+var VALID_FORMATS3 = ["text", "json", "sarif"];
+function validateOptions(options, rootDir) {
+  if (options.failOn && !VALID_FAIL_ON2.includes(options.failOn)) {
+    console.error(
+      chalk8.red(
+        `Error: Invalid --fail-on value "${options.failOn}". Must be either 'error' or 'warning'`
+      )
+    );
+    process.exit(1);
+  }
+  if (!VALID_FORMATS3.includes(options.format)) {
+    console.error(
+      chalk8.red(
+        `Error: Invalid --format value "${options.format}". Must be one of: text, json, sarif`
+      )
+    );
+    process.exit(1);
+  }
+  if (options.files) {
+    const missing = options.files.filter((file) => {
+      const fullPath = path9.isAbsolute(file) ? file : path9.join(rootDir, file);
+      return !fs7.existsSync(fullPath);
+    });
+    if (missing.length > 0) {
+      console.error(chalk8.red(`Error: File${missing.length > 1 ? "s" : ""} not found:`));
+      missing.forEach((file) => console.error(chalk8.red(`  - ${file}`)));
+      process.exit(1);
+    }
+  }
+}
+async function getDefaultBranch(rootDir) {
+  for (const remote of ["origin", "upstream"]) {
+    try {
+      const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", `${remote}/main`], {
+        cwd: rootDir,
+        timeout: 5e3
+      });
+      if (stdout.trim()) return `${remote}/main`;
+    } catch {
+    }
+    try {
+      const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", `${remote}/master`], {
+        cwd: rootDir,
+        timeout: 5e3
+      });
+      if (stdout.trim()) return `${remote}/master`;
+    } catch {
+    }
+  }
+  return "HEAD";
+}
+async function getGitChangedFiles(rootDir) {
+  const defaultBranch = await getDefaultBranch(rootDir);
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["diff", "--name-only", `${defaultBranch}...HEAD`],
+      { cwd: rootDir, timeout: 1e4 }
+    );
+    const files = stdout.trim().split("\n").filter(Boolean);
+    const { stdout: statusOut } = await execFileAsync("git", ["diff", "--name-only", "HEAD"], {
+      cwd: rootDir,
+      timeout: 1e4
+    });
+    const workingFiles = statusOut.trim().split("\n").filter(Boolean);
+    const allFiles = /* @__PURE__ */ new Set([...files, ...workingFiles]);
+    return Array.from(allFiles).filter((f) => fs7.existsSync(path9.join(rootDir, f)));
+  } catch {
+    try {
+      const { stdout } = await execFileAsync("git", ["ls-files"], { cwd: rootDir, timeout: 1e4 });
+      return stdout.trim().split("\n").filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+}
+async function isGitRepo3(rootDir) {
+  try {
+    await fs7.promises.access(path9.join(rootDir, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createLogger(verbose) {
+  if (verbose) return consoleLogger;
+  return {
+    info: () => {
+    },
+    warning: (msg) => console.error(chalk8.yellow(`Warning: ${msg}`)),
+    error: (msg) => console.error(chalk8.red(`Error: ${msg}`)),
+    debug: () => {
+    }
+  };
+}
+async function resolveFilesToReview(options, rootDir, spinner) {
+  if (options.files) return options.files;
+  if (!await isGitRepo3(rootDir)) {
+    console.error(chalk8.red("Error: Not a git repository"));
+    console.log(chalk8.yellow("Use --files to analyze specific files"));
+    process.exit(1);
+  }
+  spinner?.start("Detecting changed files...");
+  const changedFiles = await getGitChangedFiles(rootDir);
+  const analyzable = filterAnalyzableFiles(changedFiles);
+  if (analyzable.length === 0) {
+    spinner?.stop();
+    console.log(chalk8.yellow("No changed files found. Use --files to analyze specific files."));
+    return null;
+  }
+  spinner?.succeed(`Found ${analyzable.length} changed file${analyzable.length === 1 ? "" : "s"}`);
+  return analyzable;
+}
+function resolveLLMClient(options, config, logger) {
+  const noLlm = options.noLlm ?? false;
+  const apiKey = noLlm ? void 0 : resolveLLMApiKey(config);
+  if (!apiKey && !noLlm && options.format === "text") {
+    console.log(
+      chalk8.dim(
+        "No LLM API key found. Running without LLM (plugins that require LLM will be skipped).\nSet OPENROUTER_API_KEY or configure .lien/review.yml for LLM-enriched reviews."
+      )
+    );
+  }
+  const model = options.model ?? config.llm.model;
+  const llm = apiKey && !noLlm ? new OpenRouterLLMClient({ apiKey, model, logger }) : void 0;
+  if (llm && options.model) {
+    console.log(chalk8.dim(`Using model: ${model}`));
+  }
+  return { llm, model };
+}
+async function presentResults(findings, options, adapterContext) {
+  if (options.format === "sarif") {
+    await new SARIFAdapter().present(findings, adapterContext);
+  } else if (options.format === "json") {
+    console.log(JSON.stringify(findings, null, 2));
+  } else {
+    await new TerminalAdapter().present(findings, adapterContext);
+  }
+}
+async function indexAndAnalyze(rootDir, filesToReview, logger, spinner) {
+  spinner?.start("Indexing files...");
+  const indexResult = await performChunkOnlyIndex(rootDir, { filesToIndex: filesToReview });
+  if (!indexResult.success || indexResult.chunks.length === 0) {
+    spinner?.fail("Failed to index files");
+    if (indexResult.error) logger.error(indexResult.error);
+    process.exit(2);
+  }
+  spinner?.succeed(
+    `Indexed ${indexResult.filesIndexed} file${indexResult.filesIndexed === 1 ? "" : "s"} (${indexResult.chunksCreated} chunks)`
+  );
+  spinner?.start("Analyzing complexity...");
+  const complexityReport = analyzeComplexityFromChunks(indexResult.chunks, filesToReview);
+  spinner?.succeed(
+    `Complexity: ${complexityReport.summary.totalViolations} violation${complexityReport.summary.totalViolations === 1 ? "" : "s"}`
+  );
+  return { chunks: indexResult.chunks, complexityReport };
+}
+async function runReviewEngine(config, chunks, filesToReview, complexityReport, llm, logger, verbose, pluginFilter) {
+  const plugins = await loadPlugins(config);
+  const engine = new ReviewEngine({ verbose });
+  for (const plugin of plugins) {
+    engine.register(plugin);
+  }
+  const pluginConfigs = {};
+  for (const plugin of plugins) {
+    const pluginConfig = getPluginConfig(config, plugin.id);
+    if (Object.keys(pluginConfig).length > 0) {
+      pluginConfigs[plugin.id] = pluginConfig;
+    }
+  }
+  return engine.run(
+    {
+      chunks,
+      changedFiles: filesToReview,
+      complexityReport,
+      baselineReport: null,
+      deltas: null,
+      pluginConfigs,
+      config: {},
+      llm,
+      logger
+    },
+    pluginFilter
+  );
+}
+async function reviewCommand(options) {
+  const rootDir = process.cwd();
+  try {
+    validateOptions(options, rootDir);
+    const verbose = options.verbose ?? false;
+    const logger = createLogger(verbose);
+    const spinner = options.format === "text" ? ora3() : null;
+    const filesToReview = await resolveFilesToReview(options, rootDir, spinner);
+    if (!filesToReview) return;
+    const config = loadConfig(rootDir);
+    const { llm, model } = resolveLLMClient(options, config, logger);
+    const { chunks, complexityReport } = await indexAndAnalyze(
+      rootDir,
+      filesToReview,
+      logger,
+      spinner
+    );
+    spinner?.start("Running review plugins...");
+    const findings = await runReviewEngine(
+      config,
+      chunks,
+      filesToReview,
+      complexityReport,
+      llm,
+      logger,
+      verbose,
+      options.plugin
+    );
+    spinner?.succeed(
+      `Review complete: ${findings.length} finding${findings.length === 1 ? "" : "s"}`
+    );
+    await presentResults(findings, options, {
+      complexityReport,
+      baselineReport: null,
+      deltas: null,
+      deltaSummary: null,
+      logger,
+      llmUsage: llm?.getUsage(),
+      model
+    });
+    if (options.failOn) {
+      const hasMatching = options.failOn === "error" ? findings.some((f) => f.severity === "error") : findings.some((f) => f.severity === "error" || f.severity === "warning");
+      if (hasMatching) process.exit(1);
+    }
+  } catch (error) {
+    console.error(
+      chalk8.red("Error running review:"),
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(2);
+  }
+}
+
+// src/cli/config.ts
+import chalk9 from "chalk";
+import path10 from "path";
 import os3 from "os";
 import { loadGlobalConfig, mergeGlobalConfig } from "@liendev/core";
-var CONFIG_PATH = path9.join(os3.homedir(), ".lien", "config.json");
+var CONFIG_PATH = path10.join(os3.homedir(), ".lien", "config.json");
 var ALLOWED_KEYS = {
   backend: {
     values: ["lancedb", "qdrant"],
@@ -11465,50 +11725,50 @@ function buildPartialConfig(key, value) {
 async function configSetCommand(key, value) {
   const allowed = ALLOWED_KEYS[key];
   if (!allowed) {
-    console.error(chalk8.red(`Unknown config key: "${key}"`));
-    console.log(chalk8.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
+    console.error(chalk9.red(`Unknown config key: "${key}"`));
+    console.log(chalk9.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
     process.exit(1);
   }
   if (allowed.values.length > 0 && !allowed.values.includes(value)) {
-    console.error(chalk8.red(`Invalid value "${value}" for ${key}`));
-    console.log(chalk8.dim("Valid values:"), allowed.values.join(", "));
+    console.error(chalk9.red(`Invalid value "${value}" for ${key}`));
+    console.log(chalk9.dim("Valid values:"), allowed.values.join(", "));
     process.exit(1);
   }
   if (key === "qdrant.apiKey") {
     const existing = await loadGlobalConfig();
     if (!existing.qdrant?.url) {
-      console.error(chalk8.red("Set qdrant.url first before setting qdrant.apiKey"));
+      console.error(chalk9.red("Set qdrant.url first before setting qdrant.apiKey"));
       process.exit(1);
     }
   }
   const partial = buildPartialConfig(key, value);
   await mergeGlobalConfig(partial);
-  console.log(chalk8.green(`Set ${key} = ${value}`));
-  console.log(chalk8.dim(`Config: ${CONFIG_PATH}`));
+  console.log(chalk9.green(`Set ${key} = ${value}`));
+  console.log(chalk9.dim(`Config: ${CONFIG_PATH}`));
 }
 async function configGetCommand(key) {
   if (!ALLOWED_KEYS[key]) {
-    console.error(chalk8.red(`Unknown config key: "${key}"`));
-    console.log(chalk8.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
+    console.error(chalk9.red(`Unknown config key: "${key}"`));
+    console.log(chalk9.dim("Valid keys:"), Object.keys(ALLOWED_KEYS).join(", "));
     process.exit(1);
   }
   const config = await loadGlobalConfig();
   const value = getConfigValue(config, key);
   if (value === void 0) {
-    console.log(chalk8.dim(`${key}: (not set)`));
+    console.log(chalk9.dim(`${key}: (not set)`));
   } else {
     console.log(`${key}: ${value}`);
   }
 }
 async function configListCommand() {
   const config = await loadGlobalConfig();
-  console.log(chalk8.bold("Global Configuration"));
-  console.log(chalk8.dim(`File: ${CONFIG_PATH}
+  console.log(chalk9.bold("Global Configuration"));
+  console.log(chalk9.dim(`File: ${CONFIG_PATH}
 `));
   for (const [key, meta] of Object.entries(ALLOWED_KEYS)) {
     const value = getConfigValue(config, key);
-    const display = value ?? chalk8.dim("(not set)");
-    console.log(`  ${chalk8.cyan(key)}: ${display}  ${chalk8.dim(`\u2014 ${meta.description}`)}`);
+    const display = value ?? chalk9.dim("(not set)");
+    console.log(`  ${chalk9.cyan(key)}: ${display}  ${chalk9.dim(`\u2014 ${meta.description}`)}`);
   }
 }
 
@@ -11542,6 +11802,7 @@ program.command("serve").description(
 ).option("-r, --root <path>", "Root directory to serve (defaults to current directory)").action(serveCommand);
 program.command("status").description("Show indexing status and statistics").option("-v, --verbose", "Show detailed settings").option("--format <type>", "Output format: text, json", "text").action(statusCommand);
 program.command("complexity").description("Analyze code complexity").option("--files <paths...>", "Specific files to analyze").option("--format <type>", "Output format: text, json, sarif", "text").option("--fail-on <severity>", "Exit 1 if violations: error, warning").action(complexityCommand);
+program.command("review").description("Run pluggable code review on changed files").option("--files <paths...>", "Specific files to analyze (skips git diff)").option("--format <type>", "Output format: text, json, sarif", "text").option("--fail-on <severity>", "Exit 1 if findings match: error, warning").option("--no-llm", "Skip plugins that require LLM").option("--model <name>", "LLM model to use (overrides config)").option("-v, --verbose", "Show detailed logging").option("--plugin <name>", "Run only a specific plugin").action(reviewCommand);
 var configCmd = program.command("config").description("Manage global configuration (~/.lien/config.json)");
 configCmd.command("set <key> <value>").description("Set a global config value").action(configSetCommand);
 configCmd.command("get <key>").description("Get a config value").action(configGetCommand);