@coderule/mcp 1.8.0 → 2.0.1

package/dist/mcp-cli.cjs

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs4 = require('fs/promises');
-var path = require('path');
+var fs5 = require('fs/promises');
+var path2 = require('path');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var crypto = require('crypto');
 var envPaths = require('env-paths');
 var pino = require('pino');
+var os = require('os');
 var Database = require('better-sqlite3');
 var qulite = require('@coderule/qulite');
 var clients = require('@coderule/clients');
-var fs2 = require('fs');
+var fs3 = require('fs');
 var worker_threads = require('worker_threads');
 var chokidar = require('chokidar');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
@@ -18,12 +19,13 @@ var zod = require('zod');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var fs4__default = /*#__PURE__*/_interopDefault(fs4);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var fs5__default = /*#__PURE__*/_interopDefault(fs5);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
 var envPaths__default = /*#__PURE__*/_interopDefault(envPaths);
 var pino__default = /*#__PURE__*/_interopDefault(pino);
+var os__default = /*#__PURE__*/_interopDefault(os);
 var Database__default = /*#__PURE__*/_interopDefault(Database);
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
 
 // node_modules/tsup/assets/cjs_shims.js
@@ -50,6 +52,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__default.default.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(targetPath) {
+  try {
+    const stat = await fs5__default.default.stat(targetPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function hasGitDirectory(rootPath) {
+  const gitPath = path2__default.default.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__default.default.homedir();
+  const normalizedCandidate = path2__default.default.normalize(candidatePath);
+  const normalizedHome = path2__default.default.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__default.default.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";
@@ -62,9 +224,9 @@ var DEFAULTS = {
   maxSnapshotAttempts: DEFAULT_MAX_SNAPSHOT_ATTEMPTS
 };
 function normalizeRoot(root) {
-  const resolved = path__default.default.resolve(root);
-  const normalized = path__default.default.normalize(resolved);
-  return normalized.split(path__default.default.sep).join("/");
+  const resolved = path2__default.default.resolve(root);
+  const normalized = path2__default.default.normalize(resolved);
+  return normalized.split(path2__default.default.sep).join("/");
 }
 function sha256(input) {
   return crypto.createHash("sha256").update(input).digest("hex");
@@ -96,7 +258,8 @@ function parseFormatter(value) {
   );
 }
 async function resolveConfig({
-  token
+  token,
+  rootPath: cliRoot
 }) {
   const resolvedToken = token ?? process.env.CODERULE_TOKEN;
   if (!resolvedToken) {
@@ -104,14 +267,17 @@ async function resolveConfig({
       "Missing token: provide params.token or CODERULE_TOKEN env"
     );
   }
-  const rootCandidate = process.env.CODERULE_ROOT || process.cwd();
-  const rootPath = path__default.default.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__default.default("coderule").data;
-  const watchDir = path__default.default.join(dataDir, "watch");
-  await fs4__default.default.mkdir(watchDir, { recursive: true });
-  const dbPath = path__default.default.join(watchDir, `${rootId}.sqlite`);
+  const watchDir = path2__default.default.join(dataDir, "watch");
+  await fs5__default.default.mkdir(watchDir, { recursive: true });
+  const dbPath = path2__default.default.join(watchDir, `${rootId}.sqlite`);
   const baseConfig = {
     token: resolvedToken,
     rootPath,
@@ -188,6 +354,9 @@ async function resolveConfig({
   logger.debug(
     {
       rootPath,
+      rootSource: rootCandidate.source,
+      rootConfidence: rootCandidate.finalConfidence,
+      rootModifiers: rootCandidate.modifiers,
       dbPath,
       dataDir,
       authBaseUrl: baseConfig.authBaseUrl,
@@ -688,7 +857,7 @@ async function fetchVisitorRules(clients, logger2) {
   return rules;
 }
 function toPosix(input) {
-  return input.split(path__default.default.sep).join("/");
+  return input.split(path2__default.default.sep).join("/");
 }
 function getLowerBasename(input) {
   const base = input.split("/").pop();
@@ -707,7 +876,7 @@ function compileRulesBundle(rules) {
     if (!info) {
       logger.debug({ path: fullPath }, "Predicate fallback lstat");
       try {
-        info = fs2__default.default.lstatSync(fullPath);
+        info = fs3__default.default.lstatSync(fullPath);
       } catch (error) {
         logger.warn(
           { err: error, path: fullPath },
@@ -856,14 +1025,14 @@ var Hasher = class {
     await new Promise((resolve) => setImmediate(resolve));
   }
   resolveAbsolutePath(record) {
-    if (path__default.default.isAbsolute(record.display_path)) {
+    if (path2__default.default.isAbsolute(record.display_path)) {
       return record.display_path;
     }
-    return path__default.default.join(this.options.rootPath, record.rel_path);
+    return path2__default.default.join(this.options.rootPath, record.rel_path);
   }
   async ensureExists(absPath, record) {
     try {
-      await fs4__default.default.access(absPath);
+      await fs5__default.default.access(absPath);
       return true;
     } catch (error) {
       this.log.warn(
@@ -886,7 +1055,7 @@ var Hasher = class {
       const service = crypto.createHash("sha256");
       service.update(relPath);
       service.update("\n");
-      const stream = fs2__default.default.createReadStream(absPath);
+      const stream = fs3__default.default.createReadStream(absPath);
       stream.on("data", (chunk) => {
         content.update(chunk);
         service.update(chunk);
@@ -1001,13 +1170,13 @@ async function bootstrap(params) {
   return runtime;
 }
 function toPosixRelative(root, target) {
-  const rel = path__default.default.relative(root, target);
+  const rel = path2__default.default.relative(root, target);
   if (!rel || rel === "") return "";
-  return rel.split(path__default.default.sep).join("/");
+  return rel.split(path2__default.default.sep).join("/");
 }
 function isInsideRoot(root, target) {
-  const rel = path__default.default.relative(root, target);
-  return rel === "" || !rel.startsWith("..") && !path__default.default.isAbsolute(rel);
+  const rel = path2__default.default.relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !path2__default.default.isAbsolute(rel);
 }
 
 // src/fs/Walker.ts
@@ -1022,7 +1191,7 @@ function cloneStats(stats) {
 }
 async function readSymlinkTarget(absPath, log) {
   try {
-    return await fs4__default.default.readlink(absPath);
+    return await fs5__default.default.readlink(absPath);
   } catch (error) {
     log.warn({ err: error, path: absPath }, "Failed to read symlink target");
     return null;
@@ -1032,13 +1201,13 @@ async function walkDirectory(current, opts, stats) {
   const dirLogger = opts.logger;
   let dirents;
   try {
-    dirents = await fs4__default.default.readdir(current, { withFileTypes: true });
+    dirents = await fs5__default.default.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__default.default.join(current, dirent.name);
+    const absPath = path2__default.default.join(current, dirent.name);
     const relPath = toPosixRelative(opts.rootPath, absPath);
     if (dirent.isDirectory()) {
       if (shouldPruneDirectory(relPath, opts.bundle)) {
@@ -1051,7 +1220,7 @@ async function walkDirectory(current, opts, stats) {
     if (dirent.isSymbolicLink() || dirent.isFile()) {
       let stat;
       try {
-        stat = await fs4__default.default.lstat(absPath);
+        stat = await fs5__default.default.lstat(absPath);
       } catch (error) {
         dirLogger.warn({ err: error, path: absPath }, "Failed to stat file");
         continue;
@@ -1143,9 +1312,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__default.default.join(rootPath, missingFile.file_path);
+      const absPath = path2__default.default.join(rootPath, missingFile.file_path);
       try {
-        const buffer = await fs4__default.default.readFile(absPath);
+        const buffer = await fs5__default.default.readFile(absPath);
         map.set(missingFile.file_hash, {
           path: missingFile.file_path,
           content: buffer
@@ -1272,6 +1441,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(
@@ -1410,7 +1594,7 @@ function computeBackoff(attempts) {
 }
 async function readSymlinkTarget2(absPath) {
   try {
-    return await fs4__default.default.readlink(absPath);
+    return await fs5__default.default.readlink(absPath);
   } catch {
     return null;
   }
@@ -1551,7 +1735,7 @@ var ServiceRunner = class {
   async handleEvent(event, absPath, stats) {
     if (!this.running) return;
     const root = this.runtime.config.rootPath;
-    const absolute = path__default.default.isAbsolute(absPath) ? absPath : path__default.default.join(root, absPath);
+    const absolute = path2__default.default.isAbsolute(absPath) ? absPath : path2__default.default.join(root, absPath);
     if (!isInsideRoot(root, absolute)) {
       return;
     }
@@ -1571,7 +1755,7 @@ var ServiceRunner = class {
   async handleAddChange(absPath, _stats) {
     let fileStats;
     try {
-      fileStats = await fs4__default.default.lstat(absPath);
+      fileStats = await fs5__default.default.lstat(absPath);
     } catch (error) {
       this.runtime.logger.warn(
         { err: error, path: absPath },
@@ -2072,7 +2256,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",
@@ -2098,6 +2281,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)"
   );
@@ -2143,7 +2329,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];
@@ -2157,6 +2345,10 @@ function parseArgs(argv) {
       clean = true;
       continue;
     }
+    if (arg === "--exit") {
+      exit = true;
+      continue;
+    }
     if (arg === "--inline-hasher") {
       inlineHasher = true;
       continue;
@@ -2173,6 +2365,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];
@@ -2205,22 +2405,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__default.default.rm(target, { force: true })));
-  await fs4__default.default.rm(path__default.default.join(config.dataDir, "watch", `${config.rootId}.sqlite-shm`), {
+  await Promise.all(targets.map((target) => fs5__default.default.rm(target, { force: true })));
+  await fs5__default.default.rm(path2__default.default.join(config.dataDir, "watch", `${config.rootId}.sqlite-shm`), {
     force: true
   }).catch(() => {
   });
-  const dir = path__default.default.dirname(config.dbPath);
-  await fs4__default.default.mkdir(dir, { recursive: true });
+  const dir = path2__default.default.dirname(config.dbPath);
+  await fs5__default.default.mkdir(dir, { recursive: true });
   console.log(`Removed scanner database at ${config.dbPath}`);
 }
 function awaitShutdownSignals() {
@@ -2251,10 +2451,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 });