@coderule/mcp 1.4.0 → 1.6.0

package/dist/mcp-cli.js

@@ -33,6 +33,8 @@ var DEFAULT_QUEUE_POLL_INTERVAL_MS = 500;
 var DEFAULT_HASH_BATCH_SIZE = 32;
 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;
 
 // src/config/Configurator.ts
 var DEFAULT_RETRIEVAL_FORMATTER = "standard";
@@ -60,6 +62,14 @@ function parseInteger(value, fallback) {
   }
   return parsed;
 }
+function parseSecondsToMs(value, fallbackMs) {
+  if (!value) return fallbackMs;
+  const seconds = Number.parseInt(value, 10);
+  if (Number.isNaN(seconds) || seconds <= 0) {
+    throw new Error(`Invalid seconds value: ${value}`);
+  }
+  return seconds * 1e3;
+}
 function parseFormatter(value) {
   if (!value) return DEFAULT_RETRIEVAL_FORMATTER;
   const normalized = value.toLowerCase();
@@ -106,7 +116,9 @@ async function resolveConfig({
     maxSnapshotAttempts: DEFAULTS.maxSnapshotAttempts,
     retrievalFormatter: parseFormatter(
       process.env.CODERULE_RETRIEVAL_FORMATTER
-    )
+    ),
+    uploadChunkSize: DEFAULT_UPLOAD_CHUNK_SIZE,
+    maxQueryWaitMs: DEFAULT_MAX_QUERY_WAIT_MS
   };
   if (process.env.CODERULE_SNAPSHOT_DEBOUNCE_MS) {
     baseConfig.snapshotDebounceMs = parseInteger(
@@ -148,6 +160,16 @@ async function resolveConfig({
     process.env.CODERULE_HTTP_TIMEOUT,
     DEFAULT_HTTP_TIMEOUT_MS
   );
+  if (process.env.CODERULE_UPLOAD_CHUNK_SIZE) {
+    baseConfig.uploadChunkSize = parseInteger(
+      process.env.CODERULE_UPLOAD_CHUNK_SIZE,
+      baseConfig.uploadChunkSize
+    );
+  }
+  baseConfig.maxQueryWaitMs = parseSecondsToMs(
+    process.env.CODERULE_MAX_WAIT_TIME,
+    baseConfig.maxQueryWaitMs
+  );
   logger.debug(
     {
       rootPath,
@@ -1081,7 +1103,7 @@ async function withRetries(op, logger2, context, maxAttempts) {
     }
   }
 }
-async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts, chunkSize = 64) {
+async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts, chunkSize = 1) {
   if (!missing || missing.length === 0) return;
   const total = missing.length;
   const chunks = [];
@@ -1123,7 +1145,7 @@ async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts
 async function ensureSnapshotCreated(rootPath, computation, syncClient, logger2, options) {
   const { snapshotHash, files } = computation;
   const maxAttempts = options?.maxAttempts ?? 5;
-  const uploadChunkSize = options?.uploadChunkSize ?? 64;
+  const uploadChunkSize = options?.uploadChunkSize ?? 1;
   let status = await withRetries(
     () => syncClient.checkSnapshotStatus(snapshotHash),
     logger2,
@@ -1228,7 +1250,10 @@ async function runInitialSyncPipeline(runtime) {
     runtime.snapshotsRepo,
     runtime.clients.sync,
     syncLogger,
-    { maxAttempts: runtime.config.maxSnapshotAttempts }
+    {
+      maxAttempts: runtime.config.maxSnapshotAttempts,
+      uploadChunkSize: runtime.config.uploadChunkSize
+    }
   );
   return result;
 }
@@ -1632,7 +1657,10 @@ var ServiceRunner = class {
         this.runtime.snapshotsRepo,
         this.runtime.clients.sync,
         log,
-        { maxAttempts: this.runtime.config.maxSnapshotAttempts }
+        {
+          maxAttempts: this.runtime.config.maxSnapshotAttempts,
+          uploadChunkSize: this.runtime.config.uploadChunkSize
+        }
       );
       this.runtime.outbox.ack(job.id, this.fsControlLeaseOwner);
       this.state.updateSnapshotReady(result.createdAt);
@@ -1690,6 +1718,63 @@ function collectIndexingStatus(runtime, runner) {
     service: runner.getServiceStateSnapshot()
   };
 }
+function formatStatus(status) {
+  const lines = [];
+  lines.push("=== Coderule Indexing Status ===");
+  lines.push("");
+  lines.push(`Timestamp: ${new Date(status.timestamp).toISOString()}`);
+  lines.push("");
+  lines.push("Repository:");
+  lines.push(`  ID: ${status.root.id}`);
+  lines.push(`  Path: ${status.root.path}`);
+  lines.push("");
+  lines.push("Files:");
+  lines.push(`  Total: ${status.files.total}`);
+  lines.push("  States:");
+  lines.push(`    Clean: ${status.files.byState.clean}`);
+  lines.push(`    Dirty: ${status.files.byState.dirty}`);
+  lines.push(`    Hashing: ${status.files.byState.hashing}`);
+  lines.push(`    Missing: ${status.files.byState.missing}`);
+  lines.push("");
+  lines.push("Queue:");
+  lines.push(`  Pending: ${status.queue.pending}`);
+  lines.push(`  Processing: ${status.queue.processing}`);
+  lines.push(`  Done: ${status.queue.done}`);
+  lines.push(`  Failed: ${status.queue.failed}`);
+  lines.push("");
+  if (status.latestSnapshot) {
+    lines.push("Latest Snapshot:");
+    lines.push(`  Hash: ${status.latestSnapshot.snapshot_hash}`);
+    lines.push(`  Files: ${status.latestSnapshot.files_count}`);
+    lines.push(`  Size: ${formatBytes(status.latestSnapshot.total_size)}`);
+    lines.push(
+      `  Created: ${new Date(status.latestSnapshot.created_at).toISOString()}`
+    );
+  } else {
+    lines.push("Latest Snapshot: None");
+  }
+  lines.push("");
+  lines.push("Service State:");
+  lines.push(
+    `  Last Change: ${new Date(status.service.lastChangeAt).toISOString()}`
+  );
+  lines.push(
+    `  Last Snapshot Ready: ${new Date(status.service.lastSnapshotReadyAt).toISOString()}`
+  );
+  lines.push(
+    `  Last Heartbeat: ${status.service.lastHeartbeatEnqueuedAt > 0 ? new Date(status.service.lastHeartbeatEnqueuedAt).toISOString() : "Never"}`
+  );
+  lines.push(`  Watcher Ready: ${status.service.watcherReady ? "Yes" : "No"}`);
+  lines.push(`  Buffering: ${status.service.buffering ? "Yes" : "No"}`);
+  return lines.join("\n");
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${units[i]}`;
+}
 
 // src/mcp/server.ts
 var SERVER_NAME = "coderule-scanner-mcp";
@@ -1698,6 +1783,37 @@ function createMcpServer({
   runtime,
   runner
 }) {
+  async function sleep3(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function waitForLocalSnapshot(deadlineMs) {
+    let latest = runtime.snapshotsRepo.getLatest();
+    while (!latest && Date.now() < deadlineMs) {
+      await sleep3(250);
+      latest = runtime.snapshotsRepo.getLatest();
+    }
+    return latest;
+  }
+  async function waitForServerReady(initialHash, deadlineMs) {
+    let currentHash = initialHash;
+    while (Date.now() < deadlineMs) {
+      try {
+        const status = await runtime.clients.sync.checkSnapshotStatus(currentHash);
+        if (status.status === "READY") {
+          return currentHash;
+        }
+        if (status.status === "FAILED") {
+        }
+      } catch {
+      }
+      await sleep3(500);
+      const latest = runtime.snapshotsRepo.getLatest();
+      if (latest && latest.snapshot_hash !== currentHash) {
+        currentHash = latest.snapshot_hash;
+      }
+    }
+    return void 0;
+  }
   const server = new McpServer({
     name: SERVER_NAME,
     version: SERVER_VERSION,
@@ -1712,7 +1828,7 @@ function createMcpServer({
     },
     async () => {
       const status = collectIndexingStatus(runtime, runner);
-      const text = JSON.stringify(status, null, 2);
+      const text = formatStatus(status);
       return {
         content: [{ type: "text", text }]
       };
@@ -1733,38 +1849,37 @@ function createMcpServer({
       query,
       budgetTokens
     }) => {
-      const latest = runtime.snapshotsRepo.getLatest();
+      const deadline = Date.now() + runtime.config.maxQueryWaitMs;
+      const latest = await waitForLocalSnapshot(deadline);
       if (!latest) {
-        const message = "No snapshots available yet. Run indexing first.";
-        return {
-          content: [{ type: "text", text: message }],
-          isError: true
-        };
+        const statusText = formatStatus(collectIndexingStatus(runtime, runner));
+        const text = `We are not ready....
+${statusText}`;
+        return { content: [{ type: "text", text }] };
+      }
+      const readyHash = await waitForServerReady(
+        latest.snapshot_hash,
+        deadline
+      );
+      if (!readyHash) {
+        const statusText = formatStatus(collectIndexingStatus(runtime, runner));
+        const text = `We are not ready....
+${statusText}`;
+        return { content: [{ type: "text", text }] };
       }
       const effectiveBudget = Math.max(100, budgetTokens ?? 3e3);
       try {
         const result = await runtime.clients.retrieval.query(
-          latest.snapshot_hash,
+          readyHash,
           query,
           effectiveBudget,
-          {
-            formatter: runtime.config.retrievalFormatter
-          }
+          { formatter: runtime.config.retrievalFormatter }
         );
-        const summary = {
-          snapshotHash: latest.snapshot_hash,
-          budgetTokens: effectiveBudget,
-          formatter: runtime.config.retrievalFormatter
-        };
         return {
           content: [
             {
               type: "text",
               text: result.formatted_output ?? "(no formatted output)"
-            },
-            {
-              type: "text",
-              text: JSON.stringify({ summary, result }, null, 2)
             }
           ]
         };
@@ -1797,7 +1912,9 @@ var ENV_FLAG_MAP = {
   "queue-poll": "CODERULE_QUEUE_POLL_INTERVAL_MS",
   "hash-batch": "CODERULE_HASH_BATCH_SIZE",
   "hash-lease": "CODERULE_HASH_LEASE_MS",
-  "max-snapshot-attempts": "CODERULE_MAX_SNAPSHOT_ATTEMPTS"
+  "max-snapshot-attempts": "CODERULE_MAX_SNAPSHOT_ATTEMPTS",
+  "upload-chunk-size": "CODERULE_UPLOAD_CHUNK_SIZE",
+  "max-wait-time": "CODERULE_MAX_WAIT_TIME"
 };
 function printUsage() {
   console.log(`Usage: coderule-mcp-server [token] [options]
@@ -1839,6 +1956,12 @@ function printUsage() {
   console.log(
     "  --max-snapshot-attempts <n>  Override CODERULE_MAX_SNAPSHOT_ATTEMPTS"
   );
+  console.log(
+    "  --upload-chunk-size <n>      Override CODERULE_UPLOAD_CHUNK_SIZE (default 1)"
+  );
+  console.log(
+    "  --max-wait-time <sec>        Override CODERULE_MAX_WAIT_TIME (default 50s)"
+  );
   console.log(
     "  KEY=value                    Set arbitrary environment variable"
   );
@@ -1960,6 +2083,10 @@ async function main() {
     const runner = new ServiceRunner(runtime);
     try {
       await runner.prepareWatcher(true);
+      const server = createMcpServer({ runtime, runner });
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+      runtime.logger.info("MCP server connected via stdio");
       let initialCreatedAt;
       try {
         const initial = await runInitialSyncPipeline(runtime);
@@ -1968,7 +2095,7 @@ async function main() {
             snapshotHash: initial.snapshotHash,
             filesCount: initial.filesCount
           },
-          "Initial sync completed; starting MCP server"
+          "Initial sync completed; entering continuous mode"
         );
         initialCreatedAt = initial.createdAt;
       } catch (error) {
@@ -1983,10 +2110,6 @@ async function main() {
       }
       await runner.startLoops();
       await runner.enableWatcherProcessing();
-      const server = createMcpServer({ runtime, runner });
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
-      runtime.logger.info("MCP server connected via stdio");
       const signal = await awaitShutdownSignals();
       runtime.logger.info({ signal }, "Shutdown signal received");
       if (typeof transport.close === "function") {