@codragraph/cli 1.6.2

package/dist/mcp/compatible-stdio-transport.js

@@ -0,0 +1,200 @@
+import process from 'node:process';
+import { JSONRPCMessageSchema } from '@modelcontextprotocol/sdk/types.js';
+function deserializeMessage(raw) {
+    return JSONRPCMessageSchema.parse(JSON.parse(raw));
+}
+function serializeNewlineMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+function serializeContentLengthMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
+}
+function findHeaderEnd(buffer) {
+    const crlfEnd = buffer.indexOf('\r\n\r\n');
+    if (crlfEnd !== -1) {
+        return { index: crlfEnd, separatorLength: 4 };
+    }
+    const lfEnd = buffer.indexOf('\n\n');
+    if (lfEnd !== -1) {
+        return { index: lfEnd, separatorLength: 2 };
+    }
+    return null;
+}
+function looksLikeContentLength(buffer) {
+    if (buffer.length < 14) {
+        return false;
+    }
+    const probe = buffer.toString('utf8', 0, Math.min(buffer.length, 32));
+    return /^content-length\s*:/i.test(probe);
+}
+const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10 MB — generous for JSON-RPC
+export class CompatibleStdioServerTransport {
+    _stdin;
+    _stdout;
+    _readBuffer;
+    _started = false;
+    _framing = null;
+    onmessage;
+    onerror;
+    onclose;
+    constructor(_stdin = process.stdin, _stdout = process.stdout) {
+        this._stdin = _stdin;
+        this._stdout = _stdout;
+    }
+    _ondata = (chunk) => {
+        this._readBuffer = this._readBuffer ? Buffer.concat([this._readBuffer, chunk]) : chunk;
+        if (this._readBuffer.length > MAX_BUFFER_SIZE) {
+            this.onerror?.(new Error(`Read buffer exceeded maximum size (${MAX_BUFFER_SIZE} bytes)`));
+            this.discardBufferedInput();
+            return;
+        }
+        this.processReadBuffer();
+    };
+    _onerror = (error) => {
+        this.onerror?.(error);
+    };
+    async start() {
+        if (this._started) {
+            throw new Error('CompatibleStdioServerTransport already started!');
+        }
+        this._started = true;
+        this._stdin.on('data', this._ondata);
+        this._stdin.on('error', this._onerror);
+    }
+    detectFraming() {
+        if (!this._readBuffer || this._readBuffer.length === 0) {
+            return null;
+        }
+        const firstByte = this._readBuffer[0];
+        if (firstByte === 0x7b || firstByte === 0x5b) {
+            return 'newline';
+        }
+        if (looksLikeContentLength(this._readBuffer)) {
+            return 'content-length';
+        }
+        return null;
+    }
+    discardBufferedInput() {
+        this._readBuffer = undefined;
+        this._framing = null;
+    }
+    readContentLengthMessage() {
+        if (!this._readBuffer) {
+            return null;
+        }
+        const header = findHeaderEnd(this._readBuffer);
+        if (header === null) {
+            return null;
+        }
+        const headerText = this._readBuffer
+            .toString('utf8', 0, header.index)
+            .replace(/\r\n/g, '\n')
+            .replace(/\r/g, '\n');
+        const match = headerText.match(/(?:^|\n)content-length\s*:\s*(\d+)/i);
+        if (!match) {
+            this.discardBufferedInput();
+            throw new Error('Missing Content-Length header from MCP client');
+        }
+        const contentLength = Number.parseInt(match[1], 10);
+        if (!Number.isFinite(contentLength) || contentLength < 0) {
+            this.discardBufferedInput();
+            throw new Error('Invalid Content-Length header from MCP client');
+        }
+        if (contentLength > MAX_BUFFER_SIZE) {
+            this.discardBufferedInput();
+            throw new Error(`Content-Length ${contentLength} exceeds maximum allowed size (${MAX_BUFFER_SIZE} bytes)`);
+        }
+        const bodyStart = header.index + header.separatorLength;
+        const bodyEnd = bodyStart + contentLength;
+        if (this._readBuffer.length < bodyEnd) {
+            return null;
+        }
+        const body = this._readBuffer.toString('utf8', bodyStart, bodyEnd);
+        this._readBuffer = this._readBuffer.subarray(bodyEnd);
+        return deserializeMessage(body);
+    }
+    readNewlineMessage() {
+        if (!this._readBuffer) {
+            return null;
+        }
+        while (true) {
+            const newlineIndex = this._readBuffer.indexOf('\n');
+            if (newlineIndex === -1) {
+                return null;
+            }
+            const line = this._readBuffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '');
+            this._readBuffer = this._readBuffer.subarray(newlineIndex + 1);
+            if (line.trim().length === 0) {
+                continue;
+            }
+            return deserializeMessage(line);
+        }
+    }
+    readMessage() {
+        if (!this._readBuffer || this._readBuffer.length === 0) {
+            return null;
+        }
+        if (this._framing === null) {
+            this._framing = this.detectFraming();
+            if (this._framing === null) {
+                return null;
+            }
+        }
+        return this._framing === 'content-length'
+            ? this.readContentLengthMessage()
+            : this.readNewlineMessage();
+    }
+    processReadBuffer() {
+        while (true) {
+            try {
+                const message = this.readMessage();
+                if (message === null) {
+                    break;
+                }
+                this.onmessage?.(message);
+            }
+            catch (error) {
+                this.onerror?.(error);
+                break;
+            }
+        }
+    }
+    async close() {
+        this._stdin.off('data', this._ondata);
+        this._stdin.off('error', this._onerror);
+        const remainingDataListeners = this._stdin.listenerCount('data');
+        if (remainingDataListeners === 0) {
+            this._stdin.pause();
+        }
+        this._started = false;
+        this._readBuffer = undefined;
+        this.onclose?.();
+    }
+    send(message, _options) {
+        return new Promise((resolve, reject) => {
+            if (!this._started) {
+                reject(new Error('Transport is closed'));
+                return;
+            }
+            const payload = this._framing === 'newline'
+                ? serializeNewlineMessage(message)
+                : serializeContentLengthMessage(message);
+            const onError = (error) => {
+                this._stdout.removeListener('error', onError);
+                reject(error);
+            };
+            this._stdout.on('error', onError);
+            if (this._stdout.write(payload)) {
+                this._stdout.removeListener('error', onError);
+                resolve();
+            }
+            else {
+                this._stdout.once('drain', () => {
+                    this._stdout.removeListener('error', onError);
+                    resolve();
+                });
+            }
+        });
+    }
+}

package/dist/mcp/core/embedder.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Embedder Module (Read-Only)
+ *
+ * Singleton factory for transformers.js embedding pipeline.
+ * For MCP, we only need to compute query embeddings, not batch embed.
+ */
+import { type FeatureExtractionPipeline } from '@huggingface/transformers';
+/**
+ * Initialize the embedding model (lazy, on first search)
+ */
+export declare const initEmbedder: () => Promise<FeatureExtractionPipeline>;
+/**
+ * Check if embedder is ready
+ */
+export declare const isEmbedderReady: () => boolean;
+/**
+ * Embed a query text for semantic search
+ */
+export declare const embedQuery: (query: string) => Promise<number[]>;
+/**
+ * Get embedding dimensions
+ */
+export declare const getEmbeddingDims: () => number;
+/**
+ * Cleanup embedder
+ */
+export declare const disposeEmbedder: () => Promise<void>;

package/dist/mcp/core/embedder.js

@@ -0,0 +1,122 @@
+/**
+ * Embedder Module (Read-Only)
+ *
+ * Singleton factory for transformers.js embedding pipeline.
+ * For MCP, we only need to compute query embeddings, not batch embed.
+ */
+import { pipeline, env } from '@huggingface/transformers';
+import { isHttpMode, getHttpDimensions, httpEmbedQuery, } from '../../core/embeddings/http-client.js';
+import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/lbug/pool-adapter.js';
+// Model config
+const MODEL_ID = 'Snowflake/snowflake-arctic-embed-xs';
+// Module-level state for singleton pattern
+let embedderInstance = null;
+let isInitializing = false;
+let initPromise = null;
+/**
+ * Initialize the embedding model (lazy, on first search)
+ */
+export const initEmbedder = async () => {
+    if (isHttpMode()) {
+        throw new Error('initEmbedder() should not be called in HTTP mode.');
+    }
+    if (embedderInstance) {
+        return embedderInstance;
+    }
+    if (isInitializing && initPromise) {
+        return initPromise;
+    }
+    isInitializing = true;
+    initPromise = (async () => {
+        try {
+            env.allowLocalModels = false;
+            // Default cache to user-writable location. transformers.js defaults to
+            // ./node_modules/.cache inside its own install dir, which is unwritable
+            // when codragraph is installed globally (e.g. /usr/lib/node_modules/).
+            // Respect HF_HOME if set, otherwise fall back to ~/.cache/huggingface.
+            env.cacheDir = process.env.HF_HOME ?? `${process.env.HOME}/.cache/huggingface`;
+            console.error('CodraGraph: Loading embedding model (first search may take a moment)...');
+            // Try GPU first (DirectML on Windows, CUDA on Linux), fall back to CPU
+            const isWindows = process.platform === 'win32';
+            const gpuDevice = isWindows ? 'dml' : 'cuda';
+            const devicesToTry = [gpuDevice, 'cpu'];
+            for (const device of devicesToTry) {
+                try {
+                    // Silence stdout and stderr during model load — ONNX Runtime and transformers.js
+                    // may write progress/init messages that corrupt MCP stdio protocol or produce
+                    // noisy warnings (e.g. node assignment to execution providers).
+                    // Use the centralized silenceStdout() to avoid conflicts with pool-adapter's
+                    // own stdout patching (independent patching caused restore-order bugs).
+                    silenceStdout();
+                    process.stderr.write = (() => true);
+                    try {
+                        embedderInstance = await pipeline('feature-extraction', MODEL_ID, {
+                            device: device,
+                            dtype: 'fp32',
+                        });
+                    }
+                    finally {
+                        restoreStdout();
+                        process.stderr.write = realStderrWrite;
+                    }
+                    console.error(`CodraGraph: Embedding model loaded (${device})`);
+                    return embedderInstance;
+                }
+                catch {
+                    if (device === 'cpu')
+                        throw new Error('Failed to load embedding model');
+                }
+            }
+            throw new Error('No suitable device found');
+        }
+        catch (error) {
+            isInitializing = false;
+            initPromise = null;
+            embedderInstance = null;
+            throw error;
+        }
+        finally {
+            isInitializing = false;
+        }
+    })();
+    return initPromise;
+};
+/**
+ * Check if embedder is ready
+ */
+export const isEmbedderReady = () => isHttpMode() || embedderInstance !== null;
+/**
+ * Embed a query text for semantic search
+ */
+export const embedQuery = async (query) => {
+    if (isHttpMode()) {
+        return httpEmbedQuery(query);
+    }
+    const embedder = await initEmbedder();
+    const result = await embedder(query, {
+        pooling: 'mean',
+        normalize: true,
+    });
+    return Array.from(result.data);
+};
+/**
+ * Get embedding dimensions
+ */
+export const getEmbeddingDims = () => {
+    return getHttpDimensions() ?? 384;
+};
+/**
+ * Cleanup embedder
+ */
+export const disposeEmbedder = async () => {
+    if (embedderInstance) {
+        try {
+            if ('dispose' in embedderInstance && typeof embedderInstance.dispose === 'function') {
+                await embedderInstance.dispose();
+            }
+        }
+        catch { }
+        embedderInstance = null;
+        initPromise = null;
+    }
+};

package/dist/mcp/core/lbug-adapter.d.ts

@@ -0,0 +1,5 @@
+/**
+ * LadybugDB connection pool — re-exported from core.
+ * Prefer importing from `../../core/lbug/pool-adapter.js` in new code.
+ */
+export * from '../../core/lbug/pool-adapter.js';

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

@@ -0,0 +1,5 @@
+/**
+ * LadybugDB connection pool — re-exported from core.
+ * Prefer importing from `../../core/lbug/pool-adapter.js` in new code.
+ */
+export * from '../../core/lbug/pool-adapter.js';

package/dist/mcp/local/graphstore-handler.d.ts

@@ -0,0 +1,214 @@
+/**
+ * MCP dispatch for the Phase 4 versioned-graph tools.
+ *
+ * Each handler takes the repo's `storagePath` (already resolved by the
+ * caller from the optional `repo` MCP param) and returns plain JSON
+ * structures. Output is shaped for direct rendering by the agent — short
+ * strings, sorted lists, no internal CAS handles in the response.
+ */
+import { type ObjectId } from '@codragraph/graphstore';
+export interface GraphstoreLogParams {
+    readonly storagePath: string;
+    readonly limit?: number;
+    readonly from?: string;
+}
+export declare const handleGraphstoreLog: (params: GraphstoreLogParams) => Promise<{
+    branch: string;
+    head: ObjectId;
+    commits: {
+        id: string;
+        short: string;
+        snapshot: string;
+        parents: string[];
+        author: string;
+        ts: string;
+        message: string;
+    }[];
+}>;
+export interface GraphstoreBranchesParams {
+    readonly storagePath: string;
+}
+export declare const handleGraphstoreBranches: (params: GraphstoreBranchesParams) => Promise<{
+    current: string;
+    branches: {
+        name: string;
+        head: ObjectId;
+        short: string;
+        createdAt: string;
+        isCurrent: boolean;
+    }[];
+}>;
+export interface GraphstoreDiffParams {
+    readonly storagePath: string;
+    readonly from: string;
+    readonly to: string;
+}
+export declare const handleGraphstoreDiff: (params: GraphstoreDiffParams) => Promise<{
+    from: {
+        id: ObjectId;
+        short: string;
+        message: string;
+    };
+    to: {
+        id: ObjectId;
+        short: string;
+        message: string;
+    };
+    summary: {
+        addedNodes: Record<string, number>;
+        removedNodes: Record<string, number>;
+        addedEdges: number;
+        removedEdges: number;
+        modifiedSymbols: number;
+    };
+    modifiedSymbols: import("@codragraph/graphstore").ModifiedSymbol[];
+}>;
+export interface GraphstoreBlameParams {
+    readonly storagePath: string;
+    readonly symbolId: string;
+    readonly table?: string;
+    readonly limit?: number;
+}
+export declare const handleGraphstoreBlameSymbol: (params: GraphstoreBlameParams) => Promise<{
+    symbolId: string;
+    history: {
+        commitId: ObjectId;
+        short: string;
+        ts: string;
+        message: string;
+        table: string | null;
+        rowHash: ObjectId | null;
+    }[];
+}>;
+export interface GraphstoreSemanticDiffParams {
+    readonly storagePath: string;
+    readonly from: string;
+    readonly to: string;
+}
+export declare const handleGraphstoreSemanticDiff: (params: GraphstoreSemanticDiffParams) => Promise<{
+    from: {
+        id: string & {
+            readonly __brand: "codragraph-graphstore.ObjectId";
+        };
+        short: string;
+        message: string;
+    };
+    to: {
+        id: string & {
+            readonly __brand: "codragraph-graphstore.ObjectId";
+        };
+        short: string;
+        message: string;
+    };
+    summary: {
+        addedAPIs: number;
+        removedAPIs: number;
+        addedProcesses: number;
+        removedProcesses: number;
+        classifiedModifications: number;
+    };
+    addedAPIs: import("@codragraph/graphstore").SymbolRef[];
+    removedAPIs: import("@codragraph/graphstore").SymbolRef[];
+    addedProcesses: import("@codragraph/graphstore").SymbolRef[];
+    removedProcesses: import("@codragraph/graphstore").SymbolRef[];
+    classifiedModifications: import("@codragraph/graphstore").ClassifiedModification[];
+}>;
+export interface GraphstoreMergeParams {
+    readonly storagePath: string;
+    /** Branch or commit id to merge in. */
+    readonly source: string;
+    /** Branch to merge into (the "ours" side). Defaults to current branch. */
+    readonly into?: string;
+    /** Override the default merge commit message. */
+    readonly message?: string;
+    /**
+     * When true, return the conflict report instead of an error.
+     * (Conflicts are returned regardless; this just controls whether
+     * a non-conflict success/no-op path is also rendered as a "report".)
+     */
+    readonly dryRun?: boolean;
+}
+export declare const handleGraphstoreMerge: (params: GraphstoreMergeParams) => Promise<{
+    kind: string;
+    message: string;
+    branch?: undefined;
+    to?: undefined;
+    dryRun?: undefined;
+    base?: undefined;
+    conflicts?: undefined;
+    totalConflicts?: undefined;
+    snapshotId?: undefined;
+    stats?: undefined;
+    commitId?: undefined;
+} | {
+    kind: string;
+    branch: string;
+    message?: undefined;
+    to?: undefined;
+    dryRun?: undefined;
+    base?: undefined;
+    conflicts?: undefined;
+    totalConflicts?: undefined;
+    snapshotId?: undefined;
+    stats?: undefined;
+    commitId?: undefined;
+} | {
+    kind: string;
+    branch: string;
+    to: ObjectId;
+    dryRun: boolean;
+    message?: undefined;
+    base?: undefined;
+    conflicts?: undefined;
+    totalConflicts?: undefined;
+    snapshotId?: undefined;
+    stats?: undefined;
+    commitId?: undefined;
+} | {
+    kind: string;
+    branch: string;
+    base: ObjectId;
+    conflicts: import("@codragraph/graphstore").MergeConflict[];
+    totalConflicts: number;
+    message?: undefined;
+    to?: undefined;
+    dryRun?: undefined;
+    snapshotId?: undefined;
+    stats?: undefined;
+    commitId?: undefined;
+} | {
+    kind: string;
+    dryRun: boolean;
+    branch: string;
+    base: ObjectId;
+    snapshotId: ObjectId;
+    stats: import("@codragraph/graphstore").MergeStats;
+    message?: undefined;
+    to?: undefined;
+    conflicts?: undefined;
+    totalConflicts?: undefined;
+    commitId?: undefined;
+} | {
+    kind: string;
+    dryRun: boolean;
+    branch: string;
+    base: ObjectId;
+    commitId: ObjectId;
+    snapshotId: ObjectId;
+    stats: import("@codragraph/graphstore").MergeStats;
+    message?: undefined;
+    to?: undefined;
+    conflicts?: undefined;
+    totalConflicts?: undefined;
+}>;
+export interface GraphstoreGcParams {
+    readonly storagePath: string;
+    readonly dryRun?: boolean;
+}
+export declare const handleGraphstoreGc: (params: GraphstoreGcParams) => Promise<{
+    dryRun: boolean;
+    reachable: number;
+    swept: number;
+    bytesFreed: number;
+    sample: ObjectId[];
+}>;