@coderule/mcp 1.8.0 → 2.0.1

package/dist/mcp-cli.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
-import fs4 from 'fs/promises';
-import path from 'path';
+import fs5 from 'fs/promises';
+import path2 from 'path';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createHash } from 'crypto';
 import envPaths from 'env-paths';
 import pino from 'pino';
+import os from 'os';
 import Database from 'better-sqlite3';
 import { Qulite, JobStatus, enqueueFsEvent } from '@coderule/qulite';
 import { CoderuleClients, ASTHttpClient, SyncHttpClient } from '@coderule/clients';
-import fs2 from 'fs';
+import fs3 from 'fs';
 import { Worker } from 'worker_threads';
 import chokidar from 'chokidar';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -35,6 +36,166 @@ var DEFAULT_MAX_SNAPSHOT_ATTEMPTS = 5;
 var DEFAULT_HTTP_TIMEOUT_MS = 12e4;
 var DEFAULT_UPLOAD_CHUNK_SIZE = 1;
 var DEFAULT_MAX_QUERY_WAIT_MS = 5e4;
+function collectCandidateSources(options) {
+  const sources = [];
+  if (options?.cliRoot) {
+    sources.push({
+      value: options.cliRoot,
+      source: "cli-arg",
+      baseConfidence: 1
+    });
+  }
+  if (process.env.CODERULE_ROOT) {
+    sources.push({
+      value: process.env.CODERULE_ROOT,
+      source: "env-coderule-root",
+      baseConfidence: 0.9
+    });
+  }
+  if (process.env.WORKSPACE_FOLDER_PATHS) {
+    sources.push({
+      value: process.env.WORKSPACE_FOLDER_PATHS,
+      source: "env-workspace",
+      baseConfidence: 0.8
+    });
+  }
+  sources.push({
+    value: process.cwd(),
+    source: "process-cwd",
+    baseConfidence: 0.6
+  });
+  return sources;
+}
+async function pathExists(targetPath) {
+  try {
+    await fs5.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(targetPath) {
+  try {
+    const stat = await fs5.stat(targetPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function hasGitDirectory(rootPath) {
+  const gitPath = path2.join(rootPath, ".git");
+  return pathExists(gitPath);
+}
+function isShallowPath(absolutePath) {
+  const normalized = absolutePath.replace(/\\/g, "/");
+  const separatorCount = (normalized.match(/\//g) || []).length;
+  return separatorCount <= 1;
+}
+function isHomeDirectory(candidatePath) {
+  const home = os.homedir();
+  const normalizedCandidate = path2.normalize(candidatePath);
+  const normalizedHome = path2.normalize(home);
+  return normalizedCandidate === normalizedHome;
+}
+async function applyModifiers(candidate) {
+  const modifiers = [];
+  if (await hasGitDirectory(candidate.path)) {
+    modifiers.push({ reason: "has .git directory", delta: 0.1 });
+  }
+  if (isShallowPath(candidate.path)) {
+    modifiers.push({ reason: "shallow path (likely root)", delta: -0.2 });
+  }
+  if (isHomeDirectory(candidate.path)) {
+    modifiers.push({ reason: "is home directory", delta: -0.3 });
+  }
+  const totalModifier = modifiers.reduce((sum, m) => sum + m.delta, 0);
+  const finalConfidence = candidate.baseConfidence + totalModifier;
+  return {
+    ...candidate,
+    modifiers,
+    finalConfidence
+  };
+}
+async function createCandidate(source) {
+  const absolutePath = path2.resolve(source.value);
+  const exists = await pathExists(absolutePath);
+  const isDir = exists ? await isDirectory(absolutePath) : false;
+  const candidate = {
+    path: absolutePath,
+    source: source.source,
+    baseConfidence: source.baseConfidence,
+    modifiers: [],
+    finalConfidence: source.baseConfidence,
+    exists,
+    isDirectory: isDir
+  };
+  if (exists && isDir) {
+    return applyModifiers(candidate);
+  }
+  return candidate;
+}
+async function resolveRootPath(options) {
+  const logger2 = options?.logger;
+  const sources = collectCandidateSources(options);
+  const candidates = await Promise.all(sources.map(createCandidate));
+  logger2?.debug(
+    {
+      candidates: candidates.map((c) => ({
+        path: c.path,
+        source: c.source,
+        baseConfidence: c.baseConfidence,
+        finalConfidence: c.finalConfidence,
+        exists: c.exists,
+        isDirectory: c.isDirectory,
+        modifiers: c.modifiers
+      }))
+    },
+    "Collected root path candidates"
+  );
+  const validCandidates = candidates.filter((c) => c.exists && c.isDirectory);
+  if (validCandidates.length === 0) {
+    const attempted = candidates.map((c) => c.path).join(", ");
+    throw new Error(
+      `No valid root directory found. Attempted: ${attempted}. Ensure the directory exists and is accessible.`
+    );
+  }
+  const sourcePriority = {
+    "cli-arg": 1,
+    "env-coderule-root": 2,
+    "env-workspace": 3,
+    "process-cwd": 4
+  };
+  validCandidates.sort((a, b) => {
+    const confidenceDiff = b.finalConfidence - a.finalConfidence;
+    if (confidenceDiff !== 0) {
+      return confidenceDiff;
+    }
+    return sourcePriority[a.source] - sourcePriority[b.source];
+  });
+  const best = validCandidates[0];
+  if (best.finalConfidence < 0.7) {
+    logger2?.warn(
+      {
+        path: best.path,
+        source: best.source,
+        confidence: best.finalConfidence,
+        modifiers: best.modifiers
+      },
+      "Selected root path has low confidence"
+    );
+  } else {
+    logger2?.info(
+      {
+        path: best.path,
+        source: best.source,
+        confidence: best.finalConfidence,
+        modifiers: best.modifiers
+      },
+      "Resolved root path"
+    );
+  }
+  return best;
+}
 
 // src/config/Configurator.ts
 var DEFAULT_RETRIEVAL_FORMATTER = "standard";
@@ -47,9 +208,9 @@ var DEFAULTS = {
   maxSnapshotAttempts: DEFAULT_MAX_SNAPSHOT_ATTEMPTS
 };
 function normalizeRoot(root) {
-  const resolved = path.resolve(root);
-  const normalized = path.normalize(resolved);
-  return normalized.split(path.sep).join("/");
+  const resolved = path2.resolve(root);
+  const normalized = path2.normalize(resolved);
+  return normalized.split(path2.sep).join("/");
 }
 function sha256(input) {
   return createHash("sha256").update(input).digest("hex");
@@ -81,7 +242,8 @@ function parseFormatter(value) {
   );
 }
 async function resolveConfig({
-  token
+  token,
+  rootPath: cliRoot
 }) {
   const resolvedToken = token ?? process.env.CODERULE_TOKEN;
   if (!resolvedToken) {
@@ -89,14 +251,17 @@ async function resolveConfig({
       "Missing token: provide params.token or CODERULE_TOKEN env"
     );
   }
-  const rootCandidate = process.env.CODERULE_ROOT || process.cwd();
-  const rootPath = path.resolve(rootCandidate);
+  const rootCandidate = await resolveRootPath({
+    cliRoot,
+    logger: logger.child({ scope: "root-resolver" })
+  });
+  const rootPath = rootCandidate.path;
   const normalized = normalizeRoot(rootPath);
   const rootId = sha256(normalized);
   const dataDir = process.env.CODERULE_DATA_DIR || envPaths("coderule").data;
-  const watchDir = path.join(dataDir, "watch");
-  await fs4.mkdir(watchDir, { recursive: true });
-  const dbPath = path.join(watchDir, `${rootId}.sqlite`);
+  const watchDir = path2.join(dataDir, "watch");
+  await fs5.mkdir(watchDir, { recursive: true });
+  const dbPath = path2.join(watchDir, `${rootId}.sqlite`);
   const baseConfig = {
     token: resolvedToken,
     rootPath,
@@ -173,6 +338,9 @@ async function resolveConfig({
   logger.debug(
     {
       rootPath,
+      rootSource: rootCandidate.source,
+      rootConfidence: rootCandidate.finalConfidence,
+      rootModifiers: rootCandidate.modifiers,
       dbPath,
       dataDir,
       authBaseUrl: baseConfig.authBaseUrl,
@@ -673,7 +841,7 @@ async function fetchVisitorRules(clients, logger2) {
   return rules;
 }
 function toPosix(input) {
-  return input.split(path.sep).join("/");
+  return input.split(path2.sep).join("/");
 }
 function getLowerBasename(input) {
   const base = input.split("/").pop();
@@ -692,7 +860,7 @@ function compileRulesBundle(rules) {
     if (!info) {
       logger.debug({ path: fullPath }, "Predicate fallback lstat");
       try {
-        info = fs2.lstatSync(fullPath);
+        info = fs3.lstatSync(fullPath);
       } catch (error) {
         logger.warn(
           { err: error, path: fullPath },
@@ -841,14 +1009,14 @@ var Hasher = class {
     await new Promise((resolve) => setImmediate(resolve));
   }
   resolveAbsolutePath(record) {
-    if (path.isAbsolute(record.display_path)) {
+    if (path2.isAbsolute(record.display_path)) {
       return record.display_path;
     }
-    return path.join(this.options.rootPath, record.rel_path);
+    return path2.join(this.options.rootPath, record.rel_path);
   }
   async ensureExists(absPath, record) {
     try {
-      await fs4.access(absPath);
+      await fs5.access(absPath);
       return true;
     } catch (error) {
       this.log.warn(
@@ -871,7 +1039,7 @@ var Hasher = class {
       const service = createHash("sha256");
       service.update(relPath);
       service.update("\n");
-      const stream = fs2.createReadStream(absPath);
+      const stream = fs3.createReadStream(absPath);
       stream.on("data", (chunk) => {
         content.update(chunk);
         service.update(chunk);
@@ -986,13 +1154,13 @@ async function bootstrap(params) {
   return runtime;
 }
 function toPosixRelative(root, target) {
-  const rel = path.relative(root, target);
+  const rel = path2.relative(root, target);
   if (!rel || rel === "") return "";
-  return rel.split(path.sep).join("/");
+  return rel.split(path2.sep).join("/");
 }
 function isInsideRoot(root, target) {
-  const rel = path.relative(root, target);
-  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+  const rel = path2.relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !path2.isAbsolute(rel);
 }
 
 // src/fs/Walker.ts
@@ -1007,7 +1175,7 @@ function cloneStats(stats) {
 }
 async function readSymlinkTarget(absPath, log) {
   try {
-    return await fs4.readlink(absPath);
+    return await fs5.readlink(absPath);
   } catch (error) {
     log.warn({ err: error, path: absPath }, "Failed to read symlink target");
     return null;
@@ -1017,13 +1185,13 @@ async function walkDirectory(current, opts, stats) {
   const dirLogger = opts.logger;
   let dirents;
   try {
-    dirents = await fs4.readdir(current, { withFileTypes: true });
+    dirents = await fs5.readdir(current, { withFileTypes: true });
   } catch (error) {
     dirLogger.warn({ err: error, path: current }, "Failed to read directory");
     return;
   }
   for (const dirent of dirents) {
-    const absPath = path.join(current, dirent.name);
+    const absPath = path2.join(current, dirent.name);
     const relPath = toPosixRelative(opts.rootPath, absPath);
     if (dirent.isDirectory()) {
       if (shouldPruneDirectory(relPath, opts.bundle)) {
@@ -1036,7 +1204,7 @@ async function walkDirectory(current, opts, stats) {
     if (dirent.isSymbolicLink() || dirent.isFile()) {
       let stat;
       try {
-        stat = await fs4.lstat(absPath);
+        stat = await fs5.lstat(absPath);
       } catch (error) {
         dirLogger.warn({ err: error, path: absPath }, "Failed to stat file");
         continue;
@@ -1128,9 +1296,9 @@ async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts
     const list = chunks[idx];
     const map = /* @__PURE__ */ new Map();
     for (const missingFile of list) {
-      const absPath = path.join(rootPath, missingFile.file_path);
+      const absPath = path2.join(rootPath, missingFile.file_path);
       try {
-        const buffer = await fs4.readFile(absPath);
+        const buffer = await fs5.readFile(absPath);
         map.set(missingFile.file_hash, {
           path: missingFile.file_path,
           content: buffer
@@ -1257,6 +1425,21 @@ async function runInitialSyncPipeline(runtime, options) {
       hashLogger.debug("Hasher processed batch");
     }
   }
+  if (options?.blockUntilReady !== false) {
+    const syncLogger = runtime.logger.child({ scope: "snapshot" });
+    const result = await publishSnapshot(
+      runtime.config.rootPath,
+      runtime.filesRepo,
+      runtime.snapshotsRepo,
+      runtime.clients.sync,
+      syncLogger,
+      {
+        maxAttempts: runtime.config.maxSnapshotAttempts,
+        uploadChunkSize: runtime.config.uploadChunkSize
+      }
+    );
+    return result;
+  }
   const computation = computeSnapshot(runtime.filesRepo);
   const createdAt = Date.now();
   runtime.snapshotsRepo.insert(
@@ -1395,7 +1578,7 @@ function computeBackoff(attempts) {
 }
 async function readSymlinkTarget2(absPath) {
   try {
-    return await fs4.readlink(absPath);
+    return await fs5.readlink(absPath);
   } catch {
     return null;
   }
@@ -1536,7 +1719,7 @@ var ServiceRunner = class {
   async handleEvent(event, absPath, stats) {
     if (!this.running) return;
     const root = this.runtime.config.rootPath;
-    const absolute = path.isAbsolute(absPath) ? absPath : path.join(root, absPath);
+    const absolute = path2.isAbsolute(absPath) ? absPath : path2.join(root, absPath);
     if (!isInsideRoot(root, absolute)) {
       return;
     }
@@ -1556,7 +1739,7 @@ var ServiceRunner = class {
   async handleAddChange(absPath, _stats) {
     let fileStats;
     try {
-      fileStats = await fs4.lstat(absPath);
+      fileStats = await fs5.lstat(absPath);
     } catch (error) {
       this.runtime.logger.warn(
         { err: error, path: absPath },
@@ -2057,7 +2240,6 @@ ${statusText}`;
 
 // src/mcp-cli.ts
 var ENV_FLAG_MAP = {
-  root: "CODERULE_ROOT",
   "data-dir": "CODERULE_DATA_DIR",
   "auth-url": "CODERULE_AUTH_URL",
   "sync-url": "CODERULE_SYNC_URL",
@@ -2083,6 +2265,9 @@ function printUsage() {
   console.log(
     "  --clean, --reindex           Remove existing local state before running"
   );
+  console.log(
+    "  --exit                       Exit after reindex (use with --reindex)"
+  );
   console.log(
     "  --inline-hasher              Force inline hashing (debug only)"
   );
@@ -2128,7 +2313,9 @@ function printUsage() {
 }
 function parseArgs(argv) {
   let token = process.env.CODERULE_TOKEN;
+  let rootPath;
   let clean = false;
+  let exit = false;
   let inlineHasher = false;
   const env = {};
   const args = [...argv];
@@ -2142,6 +2329,10 @@ function parseArgs(argv) {
       clean = true;
       continue;
     }
+    if (arg === "--exit") {
+      exit = true;
+      continue;
+    }
     if (arg === "--inline-hasher") {
       inlineHasher = true;
       continue;
@@ -2158,6 +2349,14 @@ function parseArgs(argv) {
       token = arg.slice("--token=".length);
       continue;
     }
+    if (arg === "--root") {
+      const value = args.shift();
+      if (!value) {
+        throw new Error("Missing value for --root");
+      }
+      rootPath = value;
+      continue;
+    }
     if (arg.startsWith("--")) {
       const flag = arg.slice(2);
       const envKey = ENV_FLAG_MAP[flag];
@@ -2190,22 +2389,22 @@ function parseArgs(argv) {
       "Missing token. Provide via argument or CODERULE_TOKEN environment variable."
     );
   }
-  return { token, clean, inlineHasher, env };
+  return { token, rootPath, clean, exit, inlineHasher, env };
 }
-async function ensureClean(configToken) {
-  const config = await resolveConfig({ token: configToken });
+async function ensureClean(configToken, rootPath) {
+  const config = await resolveConfig({ token: configToken, rootPath });
   const targets = [
     config.dbPath,
     `${config.dbPath}-shm`,
     `${config.dbPath}-wal`
   ];
-  await Promise.all(targets.map((target) => fs4.rm(target, { force: true })));
-  await fs4.rm(path.join(config.dataDir, "watch", `${config.rootId}.sqlite-shm`), {
+  await Promise.all(targets.map((target) => fs5.rm(target, { force: true })));
+  await fs5.rm(path2.join(config.dataDir, "watch", `${config.rootId}.sqlite-shm`), {
     force: true
   }).catch(() => {
   });
-  const dir = path.dirname(config.dbPath);
-  await fs4.mkdir(dir, { recursive: true });
+  const dir = path2.dirname(config.dbPath);
+  await fs5.mkdir(dir, { recursive: true });
   console.log(`Removed scanner database at ${config.dbPath}`);
 }
 function awaitShutdownSignals() {
@@ -2236,10 +2435,30 @@ async function main() {
       process.env[key] = value;
     }
     if (options.clean) {
-      await ensureClean(options.token);
+      await ensureClean(options.token, options.rootPath);
     }
-    const runtime = await bootstrap({ token: options.token });
+    const runtime = await bootstrap({
+      token: options.token,
+      rootPath: options.rootPath
+    });
     const runner = new ServiceRunner(runtime);
+    if (options.exit && options.clean) {
+      try {
+        const initial = await runInitialSyncPipeline(runtime, {
+          blockUntilReady: true
+        });
+        runtime.logger.info(
+          {
+            snapshotHash: initial.snapshotHash,
+            filesCount: initial.filesCount
+          },
+          "Reindex completed; exiting"
+        );
+      } finally {
+        await runner.stop();
+      }
+      return;
+    }
     try {
       await runner.prepareWatcher(true);
       const server = createMcpServer({ runtime, runner });