@coderule/mcp 1.5.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);
@@ -1755,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,
@@ -1790,23 +1849,31 @@ 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 }
         );
         return {
           content: [
@@ -1845,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]
@@ -1887,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"
   );
@@ -2008,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);
@@ -2016,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) {
@@ -2031,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") {