gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/move/mcp-client.js

@@ -0,0 +1,436 @@
+/**
+ * MoveFlowClient implementation that spawns `move-flow mcp` and communicates
+ * via MCP JSON-RPC over stdio (newline-delimited JSON).
+ *
+ * The move-flow binary (Rust/rmcp) is expected at `process.env.MOVE_FLOW`
+ * or on $PATH as `move-flow`.
+ */
+import { spawn, execFileSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { isCompatibleMoveFlowVersion } from './release.js';
+function isMcpCallToolResult(v) {
+    return typeof v === 'object' && v !== null;
+}
+function isMcpListToolResult(v) {
+    return typeof v === 'object' && v !== null;
+}
+/** JSON-RPC `invalid_params` - move-flow uses it for caller/input errors
+ *  (and some builds route package build failures through it). */
+const JSON_RPC_INVALID_PARAMS = -32602;
+/** Real Aptos packages may need several minutes for a cold compiler build. */
+const DEFAULT_MOVE_FLOW_TOOL_TIMEOUT_MS = 300_000;
+function resolveMoveFlowToolTimeoutMs() {
+    const configured = Number(process.env.GITNEXUS_MOVE_FLOW_TIMEOUT_MS);
+    return Number.isSafeInteger(configured) && configured > 0
+        ? configured
+        : DEFAULT_MOVE_FLOW_TOOL_TIMEOUT_MS;
+}
+/**
+ * A move-flow tool call that failed in user space: the package could not be
+ * built (an `isError: true` tool result whose content text carries the
+ * diagnostic, e.g. "failed to build package `<path>`: <reason>") or the request
+ * parameters were rejected (JSON-RPC -32602 invalid_params). Distinguishes
+ * caller/input errors from transport and server faults so callers can render
+ * them as user-actionable.
+ */
+export class MoveFlowToolCallError extends Error {
+    /** JSON-RPC error code when the failure surfaced as a protocol error. */
+    code;
+    constructor(message, opts = {}) {
+        super(message);
+        this.name = 'MoveFlowToolCallError';
+        this.code = opts.code;
+    }
+}
+/**
+ * Derive move-flow capabilities from a `tools/list` response.
+ *
+ * `facts` is a *query type* on `move_package_query` (a `const` in the tool's
+ * `inputSchema` QueryType enum), not a standalone tool — so we detect it by
+ * inspecting the schema. A hypothetical future standalone `move_package_facts`
+ * tool is also honoured for forward-compatibility.
+ *
+ * Accepts either bare tool-name strings or `{ name, inputSchema }` entries.
+ */
+export function detectMoveFlowCapabilities(tools) {
+    const names = new Set();
+    let querySchema;
+    for (const t of tools) {
+        if (typeof t === 'string') {
+            names.add(t);
+        }
+        else {
+            names.add(t.name);
+            if (t.name === 'move_package_query')
+                querySchema = t.inputSchema;
+        }
+    }
+    const hasFactsQuery = names.has('move_package_facts') || schemaMentionsFactsQuery(querySchema);
+    return { hasFactsQuery, hasStatusTool: names.has('move_package_status') };
+}
+/** True if the `move_package_query` inputSchema declares a `"facts"` query const. */
+function schemaMentionsFactsQuery(schema) {
+    if (!schema || typeof schema !== 'object')
+        return false;
+    // Walk the JSON-schema object looking for a `const: "facts"` or
+    // `enum: [... "facts" ...]` anywhere under the QueryType definition.
+    const stack = [schema];
+    while (stack.length) {
+        const node = stack.pop();
+        if (!node || typeof node !== 'object')
+            continue;
+        const obj = node;
+        if (obj.const === 'facts')
+            return true;
+        if (Array.isArray(obj.enum) && obj.enum.includes('facts'))
+            return true;
+        for (const v of Object.values(obj)) {
+            if (v && typeof v === 'object')
+                stack.push(v);
+        }
+    }
+    return false;
+}
+export class MoveFlowMcpClient {
+    proc = null;
+    requestId = 0;
+    pending = new Map();
+    initialized = false;
+    initPromise = null;
+    capsPromise = null;
+    binaryPath;
+    stderrLines = [];
+    static MAX_STDERR = 20;
+    stderrContext() {
+        if (this.stderrLines.length === 0)
+            return '';
+        return `\nstderr (last ${this.stderrLines.length} lines):\n${this.stderrLines.join('\n')}`;
+    }
+    constructor(binaryPath) {
+        this.binaryPath = binaryPath || process.env.MOVE_FLOW || 'move-flow';
+    }
+    failProcess(proc, error, killProcess = true) {
+        if (this.proc !== proc)
+            return;
+        this.proc = null;
+        this.initialized = false;
+        this.initPromise = null;
+        this.capsPromise = null;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        if (killProcess) {
+            try {
+                proc.kill();
+            }
+            catch {
+                /* process may already be dead */
+            }
+        }
+    }
+    async ensureStarted() {
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        const start = this._start().catch((err) => {
+            // A failed startup must not poison the client for the rest of the run.
+            // Only clear the promise for this attempt so a late event from an older
+            // child cannot reset a newer retry.
+            if (this.initPromise === start) {
+                this.initialized = false;
+                this.initPromise = null;
+                this.capsPromise = null;
+            }
+            throw err;
+        });
+        this.initPromise = start;
+        return start;
+    }
+    async _start() {
+        return new Promise((resolve, reject) => {
+            this.stderrLines.length = 0;
+            const proc = spawn(this.binaryPath, ['mcp'], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.proc = proc;
+            let initId = null;
+            let initSettled = false;
+            let timeout = null;
+            let rl = null;
+            const clearInitTimeout = () => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+            };
+            const failInitialization = (err, killProcess = true) => {
+                if (initSettled)
+                    return;
+                initSettled = true;
+                clearInitTimeout();
+                if (initId !== null)
+                    this.pending.delete(initId);
+                rl?.close();
+                this.failProcess(proc, err, killProcess);
+                reject(err);
+            };
+            timeout = setTimeout(() => {
+                failInitialization(new Error('move-flow MCP server did not respond within 30s'));
+            }, 30000);
+            proc.stderr.on('data', (chunk) => {
+                for (const line of chunk.toString().split('\n')) {
+                    if (!line)
+                        continue;
+                    this.stderrLines.push(line);
+                    if (this.stderrLines.length > MoveFlowMcpClient.MAX_STDERR) {
+                        this.stderrLines.shift();
+                    }
+                }
+            });
+            // Absorb async EPIPE from writes to a dead child so it does not become an
+            // uncaughtException; the 'exit' handler settles in-flight requests.
+            proc.stdin.on('error', (err) => {
+                this.stderrLines.push(`stdin error: ${err.message}`);
+                if (this.stderrLines.length > MoveFlowMcpClient.MAX_STDERR) {
+                    this.stderrLines.shift();
+                }
+                const wrapped = new Error(`move-flow stdin failed: ${err.message}${this.stderrContext()}`);
+                if (!initSettled)
+                    failInitialization(wrapped);
+                else
+                    this.failProcess(proc, wrapped);
+            });
+            proc.on('error', (err) => {
+                const wrapped = new Error(`Failed to spawn move-flow: ${err.message}${this.stderrContext()}`);
+                if (!initSettled) {
+                    failInitialization(wrapped);
+                }
+                else {
+                    this.failProcess(proc, wrapped);
+                }
+            });
+            proc.on('exit', (code) => {
+                if (this.proc !== proc)
+                    return;
+                if (!initSettled) {
+                    failInitialization(new Error(`move-flow exited with code ${code} during init${this.stderrContext()}`), false);
+                    return;
+                }
+                this.failProcess(proc, new Error(`move-flow exited unexpectedly (code ${code})${this.stderrContext()}`), false);
+            });
+            rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+            rl.on('line', (line) => {
+                if (this.proc !== proc)
+                    return;
+                if (!line.trim())
+                    return;
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.id != null) {
+                        const p = this.pending.get(msg.id);
+                        if (p) {
+                            this.pending.delete(msg.id);
+                            if (msg.error) {
+                                p.reject(msg.error.code === JSON_RPC_INVALID_PARAMS
+                                    ? new MoveFlowToolCallError(msg.error.message, { code: msg.error.code })
+                                    : new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+                            }
+                            else {
+                                p.resolve(msg.result);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    /* ignore non-JSON lines */
+                }
+            });
+            // Send initialize
+            initId = ++this.requestId;
+            this.pending.set(initId, {
+                resolve: () => {
+                    if (initSettled)
+                        return;
+                    clearInitTimeout();
+                    const notif = {
+                        jsonrpc: '2.0',
+                        method: 'notifications/initialized',
+                    };
+                    try {
+                        this.send(notif);
+                    }
+                    catch (err) {
+                        failInitialization(err instanceof Error ? err : new Error(String(err)));
+                        return;
+                    }
+                    initSettled = true;
+                    this.initialized = true;
+                    resolve();
+                },
+                reject: (err) => {
+                    failInitialization(err);
+                },
+                timeout,
+            });
+            try {
+                this.send({
+                    jsonrpc: '2.0',
+                    id: initId,
+                    method: 'initialize',
+                    params: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {},
+                        clientInfo: { name: 'gitnexus', version: '1.0.0' },
+                    },
+                });
+            }
+            catch (err) {
+                failInitialization(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    send(msg) {
+        if (!this.proc)
+            throw new Error('move-flow MCP server is not running');
+        this.proc.stdin.write(JSON.stringify(msg) + '\n');
+    }
+    async request(method, params, timeoutMs, timeoutMessage) {
+        await this.ensureStarted();
+        const proc = this.proc;
+        if (!proc)
+            throw new Error('move-flow MCP server is not running');
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            const timeout = setTimeout(() => {
+                this.failProcess(proc, new Error(timeoutMessage));
+            }, timeoutMs);
+            this.pending.set(id, {
+                resolve: (result) => {
+                    clearTimeout(timeout);
+                    resolve(result);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+                timeout,
+            });
+            try {
+                this.send({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (error) {
+                this.failProcess(proc, error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    async callTool(toolName, args) {
+        const timeoutMs = resolveMoveFlowToolTimeoutMs();
+        const result = await this.request('tools/call', { name: toolName, arguments: args }, timeoutMs, `move-flow '${toolName}' timed out after ${timeoutMs}ms ` +
+            '(raise GITNEXUS_MOVE_FLOW_TIMEOUT_MS for large packages)');
+        if (!isMcpCallToolResult(result))
+            return result;
+        if (result.isError === true) {
+            const text = typeof result.content?.[0]?.text === 'string'
+                ? result.content[0].text
+                : `move-flow '${toolName}' reported an unspecified tool error`;
+            throw new MoveFlowToolCallError(text);
+        }
+        if (!result.content?.[0]?.text)
+            return result;
+        try {
+            return JSON.parse(result.content[0].text);
+        }
+        catch {
+            return result.content[0].text;
+        }
+    }
+    async callGraph(packagePath) {
+        return (await this.callTool('move_package_query', {
+            package_path: packagePath,
+            query: 'call_graph',
+        }));
+    }
+    async facts(packagePath) {
+        return (await this.callTool('move_package_query', {
+            package_path: packagePath,
+            query: 'facts',
+        }));
+    }
+    async packageStatus(packagePath) {
+        try {
+            const result = await this.callTool('move_package_status', { package_path: packagePath });
+            return { ok: true, diagnostics: typeof result === 'string' ? result : '' };
+        }
+        catch (err) {
+            // A failing build arrives as isError:true with the compiler diagnostics
+            // as content text - for this tool that IS the answer, not a call failure.
+            if (err instanceof MoveFlowToolCallError) {
+                return { ok: false, diagnostics: err.message };
+            }
+            throw err;
+        }
+    }
+    /** Raw JSON-RPC request (non-`tools/call`), e.g. `tools/list`. */
+    async rpcRequest(method, params) {
+        return this.request(method, params, 30_000, `move-flow '${method}' timed out after 30s`);
+    }
+    async capabilities() {
+        if (this.capsPromise)
+            return this.capsPromise;
+        const probe = this.rpcRequest('tools/list', {}).then((listed) => {
+            const tools = (isMcpListToolResult(listed) ? (listed.tools ?? []) : []);
+            return detectMoveFlowCapabilities(tools);
+        });
+        this.capsPromise = probe;
+        void probe.catch(() => {
+            if (this.capsPromise === probe)
+                this.capsPromise = null;
+        });
+        return probe;
+    }
+    async shutdown() {
+        const proc = this.proc;
+        if (proc) {
+            proc.stdin?.end();
+            this.failProcess(proc, new Error('move-flow client shutdown'));
+        }
+        else {
+            this.initialized = false;
+            this.initPromise = null;
+            this.capsPromise = null;
+        }
+        this.stderrLines.length = 0;
+    }
+}
+function probeBinary(binary) {
+    try {
+        const output = execFileSync(binary, ['--version'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+        });
+        // Prerelease/build suffixes ("2.1.0-rc1") are accepted; only the major
+        // version gates protocol compatibility, and it follows the release pin.
+        const version = /(?:^|\s)v?((\d+)\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\s|$)/.exec(output);
+        return version !== null && isCompatibleMoveFlowVersion(version[1]) ? version[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Construct a client for a binary that was already verified by the installer. */
+export const createMoveFlowClient = (binaryPath) => new MoveFlowMcpClient(binaryPath);
+/**
+ * Probe and resolve a move-flow candidate exactly once, returning null when
+ * the binary is missing or reports an incompatible major version. When
+ * `binaryPath` is provided only that path is probed; otherwise resolution is
+ * `$MOVE_FLOW` (explicit override), then `move-flow` on `$PATH`.
+ */
+export function tryResolveMoveFlowClient(binaryPath) {
+    const binary = binaryPath || process.env.MOVE_FLOW || 'move-flow';
+    const version = probeBinary(binary);
+    return version ? { client: createMoveFlowClient(binary), version } : null;
+}

package/dist/core/move/move-ingest.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Phase: moveIngest
+ *
+ * Compiler-first Move ingestion via the move-flow MCP server. **No raw Move
+ * source is ever read.** The `facts` query is the ONLY ingestion path: if the
+ * move-flow build doesn't expose it, the phase fails fast with a clear upgrade
+ * error before touching any package. Call edges come from the `call_graph`
+ * query.
+ *
+ * Note: move-flow's `facts` query elides all `#[test]` and `#[test_only]`
+ * symbols (functions, structs, constants). The graph therefore contains only
+ * production symbols; queries to find test functions or exclude tests from
+ * impact do not need a symbol-level test filter.
+ *
+ * @deps    structure
+ * @reads   scannedFiles (from structure phase)
+ * @writes  graph (Module/Function/Struct/Enum/EnumVariant/Const nodes +
+ *          CALLS/DEFINES/CONTAINS/FRIEND_OF/READS_RESOURCE/WRITES_RESOURCE/
+ *          ACQUIRES/USES_TYPE/ENTRY_POINT_OF/IMPORTS edges)
+ */
+import type { PipelinePhase } from '../ingestion/pipeline-phases/types.js';
+import type { StandaloneIngestOutput } from '../ingestion/pipeline-phases/standalone-ingest.js';
+import { type MoveFlowClient } from './mcp-client.js';
+import type { CallGraphMap } from './compiler-facts.js';
+import { type MoveConsistencyIssue } from './consistency.js';
+export interface MoveIngestOutput extends StandaloneIngestOutput {
+    /** Move package roots (absolute directories containing Move.toml). */
+    packageRoots: string[];
+    /** Module qualified names → source file path (repo-relative or package-root). */
+    moduleFileMap: ReadonlyMap<string, string>;
+    /** Function qualified names → graph node IDs. */
+    functionNodeMap: ReadonlyMap<string, string>;
+    /** Struct/enum qualified names → graph node IDs. */
+    structNodeMap: ReadonlyMap<string, string>;
+    /** Module qualified names → absolute package root. */
+    modulePackageMap: ReadonlyMap<string, string>;
+    /** Repo-relative file paths → absolute package root. */
+    filePackageMap: ReadonlyMap<string, string>;
+    /** Absolute package root → compiler call graph for that package. */
+    callGraphByPackage: ReadonlyMap<string, CallGraphMap>;
+    /** Resource references dropped during global resolution. */
+    droppedResourceRefs?: {
+        fnNodeId: string;
+        target: string;
+    }[];
+    /** Non-fatal consistency issues found after Move ingestion. */
+    consistencyIssues: MoveConsistencyIssue[];
+}
+export declare function createMoveIngestPhase(client: MoveFlowClient | null): PipelinePhase<MoveIngestOutput>;