gitnexus 1.6.4-rc.14 → 1.6.4-rc.16

package/README.md

@@ -156,6 +156,7 @@ gitnexus analyze --embeddings    # Enable embedding generation (slower, better s
 gitnexus analyze --skip-agents-md  # Preserve custom AGENTS.md/CLAUDE.md gitnexus section edits
 gitnexus analyze --verbose       # Log skipped files when parsers are unavailable
 gitnexus analyze --max-file-size 1024  # Skip files larger than N KB (default: 512, cap: 32768)
+gitnexus analyze --worker-timeout 60  # Increase worker idle timeout for slow parses
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
 gitnexus index                   # Register an existing .gitnexus/ folder into the global registry
@@ -323,6 +324,21 @@ npx gitnexus analyze
 
 Values above **32768 KB (32 MB)** are clamped to the tree-sitter parser ceiling; invalid values fall back to the 512 KB default with a one-time warning. When an override is active, `analyze` prints the effective threshold in its startup banner (e.g. `GITNEXUS_MAX_FILE_SIZE: effective threshold 2048KB (default 512KB)`).
 
+### Analyze reports a worker timeout
+
+Worker parse timeouts are recoverable. GitNexus retries stalled worker jobs with backoff, splits large jobs to isolate slow files, and falls back to the sequential parser when needed. If a large repository needs more time per worker job, use either:
+
+```bash
+# CLI flag, in seconds
+npx gitnexus analyze --worker-timeout 60
+
+# Environment variable, in milliseconds
+export GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=60000
+npx gitnexus analyze
+```
+
+For repositories with very large source files, `GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES` controls the worker job byte budget. The default is **8388608 bytes (8 MB)**.
+
 ## Privacy
 
 - All processing happens locally on your machine

package/dist/cli/analyze.d.ts

@@ -45,5 +45,7 @@ export interface AnalyzeOptions {
      * `GITNEXUS_MAX_FILE_SIZE` for the rest of the pipeline.
      */
     maxFileSize?: string;
+    /** Override worker sub-batch idle timeout in seconds. */
+    workerTimeout?: string;
 }
 export declare const analyzeCommand: (inputPath?: string, options?: AnalyzeOptions) => Promise<void>;

package/dist/cli/analyze.js

@@ -55,6 +55,15 @@ export const analyzeCommand = async (inputPath, options) => {
     if (options?.maxFileSize) {
         process.env.GITNEXUS_MAX_FILE_SIZE = options.maxFileSize;
     }
+    if (options?.workerTimeout) {
+        const workerTimeoutSeconds = Number(options.workerTimeout);
+        if (!Number.isFinite(workerTimeoutSeconds) || workerTimeoutSeconds < 1) {
+            console.error('  --worker-timeout must be at least 1 second.\n');
+            process.exitCode = 1;
+            return;
+        }
+        process.env.GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS = String(Math.round(workerTimeoutSeconds * 1000));
+    }
     console.log('\n  GitNexus Analyzer\n');
     let repoPath;
     if (inputPath) {

package/dist/cli/index.js

@@ -30,9 +30,12 @@ program
     'Leaves `-r <name>` ambiguous for the two paths; use -r <path> to disambiguate.')
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .option('--max-file-size <kb>', 'Skip files larger than this (KB). Default: 512. Hard cap: 32768 (tree-sitter limit).')
+    .option('--worker-timeout <seconds>', 'Worker sub-batch idle timeout before retry/fallback. Default: 30.')
     .addHelpText('after', '\nEnvironment variables:\n' +
     '  GITNEXUS_NO_GITIGNORE=1   Skip .gitignore parsing (still reads .gitnexusignore)\n' +
     '  GITNEXUS_MAX_FILE_SIZE=N  Override large-file skip threshold (KB). Default 512, max 32768.\n' +
+    '  GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=N  Worker idle timeout in milliseconds. Default 30000.\n' +
+    '  GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES=N  Worker job byte budget. Default 8388608.\n' +
     '\nTip: `.gitnexusignore` supports `.gitignore`-style negation. Add e.g.\n' +
     '     `!__tests__/` to index a directory that is auto-filtered by default (#771).')
     .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));

package/dist/core/ingestion/parsing-processor.js

@@ -555,6 +555,13 @@ export const processParsing = async (graph, files, symbolTable, astCache,
  * Pass `undefined` if no consumer needs cross-phase access.
  */
 scopeTreeCache, onFileProgress, workerPool) => {
+    let lastProgress = 0;
+    const reportProgress = onFileProgress
+        ? (current, total, detail) => {
+            lastProgress = Math.max(lastProgress, current);
+            onFileProgress(lastProgress, total, detail);
+        }
+        : undefined;
     if (workerPool) {
         if (scopeTreeCache !== undefined && process.env.PROF_SCOPE_RESOLUTION === '1') {
             // Trees can't cross MessageChannels, so worker-parsed files land
@@ -564,13 +571,15 @@ scopeTreeCache, onFileProgress, workerPool) => {
             console.warn(`[scope-resolution prof] worker pool engaged for ${files.length} files — cross-phase tree cache will be empty; scope-resolution re-parses.`);
         }
         try {
-            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
+            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, reportProgress);
         }
         catch (err) {
-            console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn('Worker pool parsing stopped; continuing with sequential parser:', message);
+            reportProgress?.(lastProgress, files.length, `Sequential fallback after worker issue: ${message}`);
         }
     }
     // Fallback: sequential parsing (no pre-extracted data)
-    await processParsingSequential(graph, files, symbolTable, astCache, scopeTreeCache, onFileProgress);
+    await processParsingSequential(graph, files, symbolTable, astCache, scopeTreeCache, reportProgress);
     return null;
 };

package/dist/core/ingestion/workers/parse-worker.js

@@ -452,7 +452,7 @@ const processBatch = (files, onProgress) => {
     }
     let totalProcessed = 0;
     let lastReported = 0;
-    const PROGRESS_INTERVAL = 100; // report every 100 files
+    const PROGRESS_INTERVAL = Math.max(1, Math.min(100, Math.ceil(files.length / 10)));
     const onFileProcessed = onProgress
         ? () => {
             totalProcessed++;
@@ -519,6 +519,9 @@ const processBatch = (files, onProgress) => {
             }
         }
     }
+    if (onProgress && totalProcessed !== lastReported) {
+        onProgress(totalProcessed);
+    }
     return result;
 };
 const ROUTE_HTTP_METHODS = new Set([

package/dist/core/ingestion/workers/worker-pool.d.ts

@@ -1,8 +1,7 @@
 export interface WorkerPool {
     /**
-     * Dispatch items across workers. Items are split into chunks (one per worker),
-     * each worker processes its chunk via sub-batches to limit peak memory,
-     * and results are concatenated back in order.
+     * Dispatch items across workers. Items are split into bounded jobs, each job
+     * is committed independently, and stalled jobs are split/retried locally.
      */
     dispatch<TInput, TResult>(items: TInput[], onProgress?: (filesProcessed: number) => void): Promise<TResult[]>;
     /** Terminate all workers. Must be called when done. */
@@ -10,7 +9,15 @@ export interface WorkerPool {
     /** Number of workers in the pool */
     readonly size: number;
 }
+export interface WorkerPoolOptions {
+    subBatchSize?: number;
+    subBatchMaxBytes?: number;
+    subBatchIdleTimeoutMs?: number;
+    maxTimeoutRetries?: number;
+    timeoutBackoffFactor?: number;
+}
+export declare function resolveWorkerPoolOptions(options?: WorkerPoolOptions): Required<WorkerPoolOptions>;
 /**
  * Create a pool of worker threads.
  */
-export declare const createWorkerPool: (workerUrl: URL, poolSize?: number) => WorkerPool;
+export declare const createWorkerPool: (workerUrl: URL, poolSize?: number, options?: WorkerPoolOptions) => WorkerPool;

package/dist/core/ingestion/workers/worker-pool.js

@@ -7,13 +7,83 @@ import { fileURLToPath } from 'node:url';
  * Keeps structured-clone memory bounded per sub-batch.
  */
 const SUB_BATCH_SIZE = 1500;
-/** Per sub-batch timeout. If a single sub-batch takes longer than this,
- *  likely a pathological file (e.g. minified 50MB JS). Fail fast. */
-const SUB_BATCH_TIMEOUT_MS = 30_000;
+const SUB_BATCH_MAX_BYTES = 8 * 1024 * 1024;
+const DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS = 30_000;
+const DEFAULT_TIMEOUT_RETRIES = 1;
+const DEFAULT_TIMEOUT_BACKOFF_FACTOR = 2;
+function positiveInteger(value) {
+    const parsed = typeof value === 'string' ? Number(value) : value;
+    return typeof parsed === 'number' && Number.isFinite(parsed) && parsed > 0
+        ? Math.floor(parsed)
+        : undefined;
+}
+function nonNegativeInteger(value) {
+    const parsed = typeof value === 'string' ? Number(value) : value;
+    return typeof parsed === 'number' && Number.isFinite(parsed) && parsed >= 0
+        ? Math.floor(parsed)
+        : undefined;
+}
+export function resolveWorkerPoolOptions(options = {}) {
+    return {
+        subBatchSize: positiveInteger(options.subBatchSize) ?? SUB_BATCH_SIZE,
+        subBatchMaxBytes: positiveInteger(options.subBatchMaxBytes) ??
+            positiveInteger(process.env.GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES) ??
+            SUB_BATCH_MAX_BYTES,
+        subBatchIdleTimeoutMs: positiveInteger(options.subBatchIdleTimeoutMs) ??
+            positiveInteger(process.env.GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS) ??
+            DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS,
+        maxTimeoutRetries: nonNegativeInteger(options.maxTimeoutRetries) ?? DEFAULT_TIMEOUT_RETRIES,
+        timeoutBackoffFactor: positiveInteger(options.timeoutBackoffFactor) ?? DEFAULT_TIMEOUT_BACKOFF_FACTOR,
+    };
+}
+function estimateItemBytes(item) {
+    if (typeof item !== 'object' || item === null)
+        return 0;
+    const content = item.content;
+    return typeof content === 'string' ? Buffer.byteLength(content, 'utf8') : 0;
+}
+function itemPath(item) {
+    if (typeof item !== 'object' || item === null)
+        return undefined;
+    const path = item.path;
+    return typeof path === 'string' ? path : undefined;
+}
+function createJobs(items, maxItems, maxBytes, timeoutMs) {
+    const jobs = [];
+    let startIndex = 0;
+    let batch = [];
+    let batchBytes = 0;
+    const flush = () => {
+        if (batch.length === 0)
+            return;
+        jobs.push({
+            startIndex,
+            items: batch,
+            estimatedBytes: batchBytes,
+            attempt: 0,
+            splitDepth: 0,
+            timeoutMs,
+        });
+        startIndex += batch.length;
+        batch = [];
+        batchBytes = 0;
+    };
+    for (const item of items) {
+        const itemBytes = estimateItemBytes(item);
+        const wouldExceedItems = batch.length >= maxItems;
+        const wouldExceedBytes = batch.length > 0 && batchBytes + itemBytes > maxBytes;
+        if (wouldExceedItems || wouldExceedBytes)
+            flush();
+        batch.push(item);
+        batchBytes += itemBytes;
+    }
+    flush();
+    return jobs;
+}
 /**
  * Create a pool of worker threads.
  */
-export const createWorkerPool = (workerUrl, poolSize) => {
+export const createWorkerPool = (workerUrl, poolSize, options) => {
     // Validate worker script exists before spawning to prevent uncaught
     // MODULE_NOT_FOUND crashes in worker threads (e.g. when running from src/ via vitest)
     const workerPath = fileURLToPath(workerUrl);
@@ -21,102 +91,228 @@ export const createWorkerPool = (workerUrl, poolSize) => {
         throw new Error(`Worker script not found: ${workerPath}`);
     }
     const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
+    const poolOptions = resolveWorkerPoolOptions(options);
     const workers = [];
+    let poolBroken = false;
+    let poolFailure;
     for (let i = 0; i < size; i++) {
         workers.push(new Worker(workerUrl));
     }
     const dispatch = (items, onProgress) => {
+        if (poolBroken) {
+            const reason = poolFailure ? `: ${poolFailure.message}` : '';
+            return Promise.reject(new Error(`Worker pool is unavailable after a previous failure${reason}`));
+        }
         if (items.length === 0)
             return Promise.resolve([]);
-        const chunkSize = Math.ceil(items.length / size);
-        const chunks = [];
-        for (let i = 0; i < items.length; i += chunkSize) {
-            chunks.push(items.slice(i, i + chunkSize));
-        }
-        const workerProgress = new Array(chunks.length).fill(0);
-        const promises = chunks.map((chunk, i) => {
-            const worker = workers[i];
-            return new Promise((resolve, reject) => {
+        if (workers.length === 0)
+            return Promise.reject(new Error('Worker pool has no active workers'));
+        const jobs = createJobs(items, poolOptions.subBatchSize, poolOptions.subBatchMaxBytes, poolOptions.subBatchIdleTimeoutMs);
+        return new Promise((resolve, reject) => {
+            const results = [];
+            const inFlightProgress = new Array(workers.length).fill(0);
+            let completedFiles = 0;
+            let activeWorkers = 0;
+            let stopped = false;
+            let maxReported = 0;
+            const reportProgress = () => {
+                if (!onProgress)
+                    return;
+                const inFlight = inFlightProgress.reduce((sum, value) => sum + value, 0);
+                const next = Math.min(items.length, Math.max(maxReported, completedFiles + inFlight));
+                if (next === maxReported)
+                    return;
+                maxReported = next;
+                onProgress(next);
+            };
+            const replaceWorker = async (workerIndex) => {
+                const worker = workers[workerIndex];
+                await worker?.terminate().catch(() => undefined);
+                if (!stopped)
+                    workers[workerIndex] = new Worker(workerUrl);
+            };
+            const fail = async (err) => {
+                poolBroken = true;
+                poolFailure = err;
+                if (stopped)
+                    return;
+                stopped = true;
+                await Promise.all(workers.map((worker) => worker.terminate().catch(() => undefined)));
+                reject(err);
+            };
+            const maybeDone = () => {
+                if (stopped)
+                    return;
+                if (jobs.length === 0 && activeWorkers === 0) {
+                    stopped = true;
+                    results.sort((a, b) => a.startIndex - b.startIndex);
+                    if (onProgress && maxReported < items.length)
+                        onProgress(items.length);
+                    resolve(results.map((result) => result.data));
+                }
+            };
+            const requeueAfterTimeout = (workerIndex, job, lastProgress) => {
+                const nextTimeout = Math.ceil(job.timeoutMs * poolOptions.timeoutBackoffFactor);
+                if (job.items.length > 1) {
+                    const midpoint = Math.ceil(job.items.length / 2);
+                    const firstItems = job.items.slice(0, midpoint);
+                    const secondItems = job.items.slice(midpoint);
+                    const first = {
+                        startIndex: job.startIndex,
+                        items: firstItems,
+                        estimatedBytes: firstItems.reduce((sum, item) => sum + estimateItemBytes(item), 0),
+                        attempt: job.attempt,
+                        splitDepth: job.splitDepth + 1,
+                        timeoutMs: nextTimeout,
+                    };
+                    const second = {
+                        startIndex: job.startIndex + midpoint,
+                        items: secondItems,
+                        estimatedBytes: secondItems.reduce((sum, item) => sum + estimateItemBytes(item), 0),
+                        attempt: job.attempt,
+                        splitDepth: job.splitDepth + 1,
+                        timeoutMs: nextTimeout,
+                    };
+                    console.warn(`Worker ${workerIndex} parse job idle timeout after ${job.timeoutMs / 1000}s ` +
+                        `(${job.items.length} items, ${job.estimatedBytes} bytes, last progress: ${lastProgress}). ` +
+                        `Splitting into ${first.items.length}/${second.items.length} item jobs with ` +
+                        `${nextTimeout / 1000}s timeout.`);
+                    // Preserve intuitive retry order; final result order is still enforced by startIndex sort.
+                    jobs.unshift(first, second);
+                    return true;
+                }
+                const nextAttempt = job.attempt + 1;
+                if (nextAttempt <= poolOptions.maxTimeoutRetries) {
+                    console.warn(`Worker ${workerIndex} parse job idle timeout after ${job.timeoutMs / 1000}s ` +
+                        `(single item, attempt ${nextAttempt}/${poolOptions.maxTimeoutRetries + 1}). ` +
+                        `Retrying with ${nextTimeout / 1000}s timeout.`);
+                    jobs.unshift({
+                        ...job,
+                        attempt: nextAttempt,
+                        timeoutMs: nextTimeout,
+                    });
+                    return true;
+                }
+                void fail(new Error(`Worker ${workerIndex} parse job idle timeout after ${job.timeoutMs / 1000}s ` +
+                    `(single item${itemPath(job.items[0]) ? `: ${itemPath(job.items[0])}` : ''}, ` +
+                    `${job.estimatedBytes} bytes, last progress: ${lastProgress}). ` +
+                    `Analyze will retry through sequential fallback. Increase with ` +
+                    `--worker-timeout or GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS.`));
+                return false;
+            };
+            const runWorker = (workerIndex) => {
+                if (stopped)
+                    return;
+                const job = jobs.shift();
+                if (!job) {
+                    maybeDone();
+                    return;
+                }
+                activeWorkers++;
+                inFlightProgress[workerIndex] = 0;
+                const worker = workers[workerIndex];
                 let settled = false;
-                let subBatchTimer = null;
+                let waitingForFlush = false;
+                let idleTimer = null;
+                let lastProgress = 0;
                 const cleanup = () => {
-                    if (subBatchTimer)
-                        clearTimeout(subBatchTimer);
+                    if (idleTimer)
+                        clearTimeout(idleTimer);
                     worker.removeListener('message', handler);
                     worker.removeListener('error', errorHandler);
                     worker.removeListener('exit', exitHandler);
                 };
-                const resetSubBatchTimer = () => {
-                    if (subBatchTimer)
-                        clearTimeout(subBatchTimer);
-                    subBatchTimer = setTimeout(() => {
+                const finishJob = () => {
+                    activeWorkers--;
+                    inFlightProgress[workerIndex] = 0;
+                    runWorker(workerIndex);
+                    maybeDone();
+                };
+                const resetIdleTimer = () => {
+                    if (idleTimer)
+                        clearTimeout(idleTimer);
+                    idleTimer = setTimeout(async () => {
                         if (!settled) {
                             settled = true;
                             cleanup();
-                            reject(new Error(`Worker ${i} sub-batch timed out after ${SUB_BATCH_TIMEOUT_MS / 1000}s (chunk: ${chunk.length} items).`));
+                            activeWorkers--;
+                            inFlightProgress[workerIndex] = 0;
+                            const shouldContinue = requeueAfterTimeout(workerIndex, job, lastProgress);
+                            if (!shouldContinue)
+                                return;
+                            await replaceWorker(workerIndex);
+                            reportProgress();
+                            runWorker(workerIndex);
+                            maybeDone();
                         }
-                    }, SUB_BATCH_TIMEOUT_MS);
-                };
-                let subBatchIdx = 0;
-                const sendNextSubBatch = () => {
-                    const start = subBatchIdx * SUB_BATCH_SIZE;
-                    if (start >= chunk.length) {
-                        worker.postMessage({ type: 'flush' });
-                        return;
-                    }
-                    const subBatch = chunk.slice(start, start + SUB_BATCH_SIZE);
-                    subBatchIdx++;
-                    resetSubBatchTimer();
-                    worker.postMessage({ type: 'sub-batch', files: subBatch });
+                    }, job.timeoutMs);
                 };
                 const handler = (msg) => {
-                    if (settled)
+                    if (settled || stopped)
                         return;
                     if (msg.type === 'progress') {
-                        workerProgress[i] = msg.filesProcessed;
-                        if (onProgress) {
-                            const total = workerProgress.reduce((a, b) => a + b, 0);
-                            onProgress(total);
-                        }
+                        const bounded = Math.min(job.items.length, Math.max(0, msg.filesProcessed));
+                        inFlightProgress[workerIndex] = bounded;
+                        lastProgress = bounded;
+                        resetIdleTimer();
+                        reportProgress();
                     }
                     else if (msg.type === 'warning') {
+                        resetIdleTimer();
                         console.warn(msg.message);
                     }
                     else if (msg.type === 'sub-batch-done') {
-                        sendNextSubBatch();
+                        waitingForFlush = true;
+                        resetIdleTimer();
+                        worker.postMessage({ type: 'flush' });
                     }
                     else if (msg.type === 'error') {
                         settled = true;
                         cleanup();
-                        reject(new Error(`Worker ${i} error: ${msg.error}`));
+                        void fail(new Error(`Worker ${workerIndex} error: ${msg.error}`));
                     }
                     else if (msg.type === 'result') {
+                        if (!waitingForFlush) {
+                            settled = true;
+                            cleanup();
+                            void fail(new Error(`Worker ${workerIndex} protocol error: result before flush`));
+                            return;
+                        }
                         settled = true;
                         cleanup();
-                        resolve(msg.data);
+                        results.push({ startIndex: job.startIndex, data: msg.data });
+                        completedFiles += job.items.length;
+                        reportProgress();
+                        finishJob();
                     }
                 };
                 const errorHandler = (err) => {
                     if (!settled) {
                         settled = true;
                         cleanup();
-                        reject(err);
+                        void fail(err);
                     }
                 };
                 const exitHandler = (code) => {
                     if (!settled) {
                         settled = true;
                         cleanup();
-                        reject(new Error(`Worker ${i} exited with code ${code}. Likely OOM or native addon failure.`));
+                        void fail(new Error(`Worker ${workerIndex} exited with code ${code}. Likely OOM or native addon failure.`));
                     }
                 };
                 worker.on('message', handler);
                 worker.once('error', errorHandler);
                 worker.once('exit', exitHandler);
-                sendNextSubBatch();
-            });
+                resetIdleTimer();
+                if (stopped) {
+                    cleanup();
+                    return;
+                }
+                worker.postMessage({ type: 'sub-batch', files: job.items });
+            };
+            for (let i = 0; i < workers.length; i++)
+                runWorker(i);
         });
-        return Promise.all(promises);
     };
     const terminate = async () => {
         await Promise.all(workers.map((w) => w.terminate()));

package/dist/core/lbug/lbug-adapter.js

@@ -287,7 +287,8 @@ const doInitLbug = async (dbPath) => {
             }
         }
     }
-    // Load VECTOR extension for semantic search support
+    // Load query extensions once per core adapter session.
+    await loadFTSExtension();
     await loadVectorExtension();
     currentDbPath = dbPath;
     return { db, conn };

package/dist/core/run-analyze.js

@@ -140,7 +140,8 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     const pipelineResult = await runPipelineFromRepo(repoPath, (p) => {
         const phaseLabel = PHASE_LABELS[p.phase] || p.phase;
         const scaled = Math.round(p.percent * 0.6);
-        progress(p.phase, scaled, phaseLabel);
+        const message = p.detail ? `${p.message || phaseLabel} (${p.detail})` : p.message || phaseLabel;
+        progress(p.phase, scaled, message);
     });
     // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────
     progress('lbug', 60, 'Loading into LadybugDB...');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.14",
+  "version": "1.6.4-rc.16",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",