@coderule/mcp 2.2.0 → 2.2.2

package/dist/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import fs5 from 'fs/promises';
+import fs8 from 'fs/promises';
 import path2 from 'path';
+import { CoderuleClients, ASTHttpClient, SyncHttpClient } from '@coderule/clients';
 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 fs3 from 'fs';
 import { Worker } from 'worker_threads';
 import chokidar from 'chokidar';
@@ -65,7 +65,7 @@ function collectCandidateSources(options) {
 }
 async function pathExists(targetPath) {
   try {
-    await fs5.access(targetPath);
+    await fs8.access(targetPath);
     return true;
   } catch {
     return false;
@@ -73,7 +73,7 @@ async function pathExists(targetPath) {
 }
 async function isDirectory(targetPath) {
   try {
-    const stat = await fs5.stat(targetPath);
+    const stat = await fs8.stat(targetPath);
     return stat.isDirectory();
   } catch {
     return false;
@@ -257,7 +257,7 @@ async function resolveConfig({
   const rootId = sha256(normalized);
   const dataDir = process.env.CODERULE_DATA_DIR || envPaths("coderule").data;
   const watchDir = path2.join(dataDir, "watch");
-  await fs5.mkdir(watchDir, { recursive: true });
+  await fs8.mkdir(watchDir, { recursive: true });
   const dbPath = path2.join(watchDir, `${rootId}.sqlite`);
   const baseConfig = {
     token: resolvedToken,
@@ -1033,7 +1033,7 @@ var Hasher = class {
   }
   async ensureExists(absPath, record) {
     try {
-      await fs5.access(absPath);
+      await fs8.access(absPath);
       return true;
     } catch (error) {
       this.log.warn(
@@ -1194,7 +1194,7 @@ function cloneStats(stats) {
 }
 async function readSymlinkTarget(absPath, log) {
   try {
-    return await fs5.readlink(absPath);
+    return await fs8.readlink(absPath);
   } catch (error) {
     log.warn({ err: error, path: absPath }, "Failed to read symlink target");
     return null;
@@ -1204,7 +1204,7 @@ async function walkDirectory(current, opts, stats) {
   const dirLogger = opts.logger;
   let dirents;
   try {
-    dirents = await fs5.readdir(current, { withFileTypes: true });
+    dirents = await fs8.readdir(current, { withFileTypes: true });
   } catch (error) {
     dirLogger.warn({ err: error, path: current }, "Failed to read directory");
     return;
@@ -1223,7 +1223,7 @@ async function walkDirectory(current, opts, stats) {
     if (dirent.isSymbolicLink() || dirent.isFile()) {
       let stat;
       try {
-        stat = await fs5.lstat(absPath);
+        stat = await fs8.lstat(absPath);
       } catch (error) {
         dirLogger.warn({ err: error, path: absPath }, "Failed to stat file");
         continue;
@@ -1366,7 +1366,7 @@ async function uploadMissing(rootPath, missing, syncClient, logger2, maxAttempts
     for (const missingFile of list) {
       const absPath = path2.join(rootPath, missingFile.file_path);
       try {
-        const buffer = await fs5.readFile(absPath);
+        const buffer = await fs8.readFile(absPath);
         const serviceHash = computeServiceFileHash(
           missingFile.file_path,
           buffer
@@ -1679,7 +1679,7 @@ function computeBackoff(attempts) {
 var PUBLISH_MAX_MS = 5 * 6e4;
 async function readSymlinkTarget2(absPath) {
   try {
-    return await fs5.readlink(absPath);
+    return await fs8.readlink(absPath);
   } catch {
     return null;
   }
@@ -1840,7 +1840,7 @@ var ServiceRunner = class {
   async handleAddChange(absPath, _stats) {
     let fileStats;
     try {
-      fileStats = await fs5.lstat(absPath);
+      fileStats = await fs8.lstat(absPath);
     } catch (error) {
       this.runtime.logger.warn(
         { err: error, path: absPath },
@@ -2150,6 +2150,8 @@ Options:
   --max-snapshot-attempts <n> Override CODERULE_MAX_SNAPSHOT_ATTEMPTS
   --upload-chunk-size <n>    Override CODERULE_UPLOAD_CHUNK_SIZE (default 1)
   --max-wait-time <sec>      Override CODERULE_MAX_WAIT_TIME (default 50s)
+  --dump-bush <path>         Download HDF5 bush file to <path> (must end with .h5)
+  --dump-skill               Print HDF5 bush reader skill (format docs + examples)
   KEY=value                  Set arbitrary environment variable
   --help                     Show this message
 `);
@@ -2160,6 +2162,8 @@ function parseArgs(argv) {
   let mode = "service";
   let clean = false;
   let inlineHasher = false;
+  let dumpBush;
+  let dumpSkill = false;
   const env = {};
   const args = [...argv];
   while (args.length > 0) {
@@ -2184,6 +2188,22 @@ function parseArgs(argv) {
       inlineHasher = true;
       continue;
     }
+    if (arg === "--dump-bush") {
+      if (args.length === 0) {
+        throw new Error("Option --dump-bush requires a file path");
+      }
+      dumpBush = args.shift();
+      if (!dumpBush.endsWith(".h5")) {
+        throw new Error("--dump-bush path must end with .h5");
+      }
+      mode = "initial";
+      continue;
+    }
+    if (arg === "--dump-skill") {
+      dumpSkill = true;
+      mode = "initial";
+      continue;
+    }
     if (arg === "--root") {
       if (args.length === 0) {
         throw new Error("Option --root requires a value");
@@ -2223,7 +2243,16 @@ function parseArgs(argv) {
       "Missing token. Provide via argument or CODERULE_TOKEN env."
     );
   }
-  return { token, rootPath, mode, clean, inlineHasher, env };
+  return {
+    token,
+    rootPath,
+    mode,
+    clean,
+    inlineHasher,
+    dumpBush,
+    dumpSkill,
+    env
+  };
 }
 async function ensureClean(configToken, rootPath) {
   const config = await resolveConfig({ token: configToken, rootPath });
@@ -2232,13 +2261,13 @@ async function ensureClean(configToken, rootPath) {
     `${config.dbPath}-shm`,
     `${config.dbPath}-wal`
   ];
-  await Promise.all(targets.map((target) => fs5.rm(target, { force: true })));
-  await fs5.rm(path2.join(config.dataDir, "watch", `${config.rootId}.sqlite-shm`), {
+  await Promise.all(targets.map((target) => fs8.rm(target, { force: true })));
+  await fs8.rm(path2.join(config.dataDir, "watch", `${config.rootId}.sqlite-shm`), {
     force: true
   }).catch(() => {
   });
   const dir = path2.dirname(config.dbPath);
-  await fs5.mkdir(dir, { recursive: true });
+  await fs8.mkdir(dir, { recursive: true });
   console.log(`Removed scanner database at ${config.dbPath}`);
 }
 async function main() {
@@ -2263,6 +2292,29 @@ async function main() {
         rootPath: options.rootPath
       });
       console.log("Initial sync result:", JSON.stringify(result, null, 2));
+      if (options.dumpBush || options.dumpSkill) {
+        const clients = new CoderuleClients({ token: options.token });
+        try {
+          await clients.sync.checkSnapshotStatus(result.snapshotHash);
+          if (options.dumpBush) {
+            const buf = await clients.sync.downloadSnapshotBush(
+              result.snapshotHash
+            );
+            const dir = path2.dirname(options.dumpBush);
+            await fs8.mkdir(dir, { recursive: true });
+            await fs8.writeFile(options.dumpBush, Buffer.from(buf));
+            console.log(
+              `HDF5 bush saved to ${options.dumpBush} (${buf.byteLength} bytes)`
+            );
+          }
+          if (options.dumpSkill) {
+            const skill = await clients.sync.getHdf5BushReaderSkill();
+            console.log(skill);
+          }
+        } finally {
+          clients.close();
+        }
+      }
     } else {
       await runService({ token: options.token, rootPath: options.rootPath });
     }