@coderule/mcp 1.5.0 → 1.6.1

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,
@@ -1205,7 +1227,7 @@ async function publishSnapshot(rootPath, filesRepo, snapshotsRepo, syncClient, l
 }
 
 // src/service/InitialSync.ts
-async function runInitialSyncPipeline(runtime) {
+async function runInitialSyncPipeline(runtime, options) {
   const inventoryLogger = runtime.logger.child({ scope: "inventory" });
   await runInventory({
     rootPath: runtime.config.rootPath,
@@ -1221,16 +1243,22 @@ async function runInitialSyncPipeline(runtime) {
       hashLogger.debug("Hasher processed batch");
     }
   }
-  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 }
+  const computation = computeSnapshot(runtime.filesRepo);
+  const createdAt = Date.now();
+  runtime.snapshotsRepo.insert(
+    computation.snapshotHash,
+    computation.filesCount,
+    computation.totalSize,
+    createdAt
   );
-  return result;
+  runtime.outbox.enqueueSnapshot(runtime.config.rootId, 0);
+  return {
+    snapshotHash: computation.snapshotHash,
+    filesCount: computation.filesCount,
+    totalSize: computation.totalSize,
+    status: "READY",
+    createdAt
+  };
 }
 async function createChokidarWatcher(options, usePolling) {
   const log = options.logger.child({
@@ -1632,7 +1660,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 +1786,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 +1852,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 +1915,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 +1959,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,15 +2086,21 @@ 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);
+        const initial = await runInitialSyncPipeline(runtime, {
+          blockUntilReady: false
+        });
         runtime.logger.info(
           {
             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 +2115,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") {