reasonix 0.2.2 → 0.3.0-alpha.2

package/dist/index.js

@@ -1355,6 +1355,14 @@ function recordFromLoopEvent(ev, extra) {
   if (ev.toolName !== void 0) rec.tool = ev.toolName;
   if (ev.toolArgs !== void 0) rec.args = ev.toolArgs;
   if (ev.error !== void 0) rec.error = ev.error;
+  if (ev.planState && !isPlanStateEmptyShape(ev.planState)) {
+    rec.planState = {
+      subgoals: [...ev.planState.subgoals],
+      hypotheses: [...ev.planState.hypotheses],
+      uncertainties: [...ev.planState.uncertainties],
+      rejectedPaths: [...ev.planState.rejectedPaths]
+    };
+  }
   if (ev.stats) {
     rec.usage = {
       prompt_tokens: ev.stats.usage.promptTokens,
@@ -1390,6 +1398,9 @@ function readTranscript(path) {
   const raw = readFileSync3(path, "utf8");
   return parseTranscript(raw);
 }
+function isPlanStateEmptyShape(s) {
+  return s.subgoals.length === 0 && s.hypotheses.length === 0 && s.uncertainties.length === 0 && s.rejectedPaths.length === 0;
+}
 function parseTranscript(raw) {
   const out = { meta: null, records: [] };
   for (const line of raw.split(/\r?\n/)) {
@@ -1425,12 +1436,20 @@ function computeReplayStats(records) {
   const prefixHashes = /* @__PURE__ */ new Set();
   let userTurns = 0;
   let toolCalls = 0;
+  let harvestedTurns = 0;
+  let totalUncertainties = 0;
+  let totalSubgoals = 0;
   for (const rec of records) {
     if (rec.role === "user") userTurns++;
     else if (rec.role === "tool") toolCalls++;
     else if (rec.role === "assistant_final") {
       if (rec.model) models.add(rec.model);
       if (rec.prefixHash) prefixHashes.add(rec.prefixHash);
+      if (rec.planState) {
+        harvestedTurns++;
+        totalUncertainties += rec.planState.uncertainties.length;
+        totalSubgoals += rec.planState.subgoals.length;
+      }
       if (rec.usage && rec.model) {
         const u = new Usage(
           rec.usage.prompt_tokens ?? 0,
@@ -1458,6 +1477,9 @@ function computeReplayStats(records) {
     prefixHashes: [...prefixHashes],
     userTurns,
     toolCalls,
+    harvestedTurns,
+    totalUncertainties,
+    totalSubgoals,
     ...summarizeTurns(turns)
   };
 }
@@ -1628,6 +1650,41 @@ function renderSummaryTable(report, _opts = {}) {
     )
   );
   lines.push(statRow("prefix hashes", a.stats.prefixHashes.length, b.stats.prefixHashes.length));
+  if (a.stats.harvestedTurns > 0 || b.stats.harvestedTurns > 0) {
+    lines.push(
+      row(
+        [
+          "harvest turns",
+          `${a.stats.harvestedTurns}`,
+          `${b.stats.harvestedTurns}`,
+          signed(b.stats.harvestedTurns - a.stats.harvestedTurns)
+        ],
+        [20, 14, 14, 14]
+      )
+    );
+    lines.push(
+      row(
+        [
+          "  subgoals",
+          `${a.stats.totalSubgoals}`,
+          `${b.stats.totalSubgoals}`,
+          signed(b.stats.totalSubgoals - a.stats.totalSubgoals)
+        ],
+        [20, 14, 14, 14]
+      )
+    );
+    lines.push(
+      row(
+        [
+          "  uncertainties",
+          `${a.stats.totalUncertainties}`,
+          `${b.stats.totalUncertainties}`,
+          signed(b.stats.totalUncertainties - a.stats.totalUncertainties)
+        ],
+        [20, 14, 14, 14]
+      )
+    );
+  }
   lines.push("");
   const aPrefixStable = a.stats.prefixHashes.length <= 1;
   const bPrefixStable = b.stats.prefixHashes.length <= 1;
@@ -1699,6 +1756,17 @@ function renderMarkdown(report) {
   out.push(
     `| prefix hashes | ${a.stats.prefixHashes.length} | ${b.stats.prefixHashes.length} | \u2014 |`
   );
+  if (a.stats.harvestedTurns > 0 || b.stats.harvestedTurns > 0) {
+    out.push(
+      `| harvest turns | ${a.stats.harvestedTurns} | ${b.stats.harvestedTurns} | ${signed(b.stats.harvestedTurns - a.stats.harvestedTurns)} |`
+    );
+    out.push(
+      `| harvest subgoals | ${a.stats.totalSubgoals} | ${b.stats.totalSubgoals} | ${signed(b.stats.totalSubgoals - a.stats.totalSubgoals)} |`
+    );
+    out.push(
+      `| harvest uncertainties | ${a.stats.totalUncertainties} | ${b.stats.totalUncertainties} | ${signed(b.stats.totalUncertainties - a.stats.totalUncertainties)} |`
+    );
+  }
   out.push("");
   out.push("## Turn-by-turn");
   out.push("");
@@ -1766,6 +1834,278 @@ function truncate(s, n) {
   return s.length > n ? `${s.slice(0, n)}\u2026` : s;
 }
 
+// src/mcp/types.ts
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+function isJsonRpcError(msg) {
+  return "error" in msg;
+}
+
+// src/mcp/client.ts
+var McpClient = class {
+  transport;
+  clientInfo;
+  requestTimeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  readerStarted = false;
+  initialized = false;
+  _serverCapabilities = {};
+  constructor(opts) {
+    this.transport = opts.transport;
+    this.clientInfo = opts.clientInfo ?? { name: "reasonix", version: "0.3.0-dev" };
+    this.requestTimeoutMs = opts.requestTimeoutMs ?? 6e4;
+  }
+  /** Server's advertised capabilities, available after initialize(). */
+  get serverCapabilities() {
+    return this._serverCapabilities;
+  }
+  /**
+   * Complete the initialize → initialized handshake. Must be called
+   * before any other method (otherwise compliant servers reject).
+   */
+  async initialize() {
+    if (this.initialized) throw new Error("MCP client already initialized");
+    this.startReaderIfNeeded();
+    const result = await this.request("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: { tools: {} },
+      clientInfo: this.clientInfo
+    });
+    this._serverCapabilities = result.capabilities ?? {};
+    await this.transport.send({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    });
+    this.initialized = true;
+    return result;
+  }
+  /** List tools the server exposes. */
+  async listTools() {
+    this.assertInitialized();
+    return this.request("tools/list", {});
+  }
+  /** Invoke a tool by name. Returns the raw MCP result (caller unwraps content). */
+  async callTool(name, args) {
+    this.assertInitialized();
+    return this.request("tools/call", {
+      name,
+      arguments: args ?? {}
+    });
+  }
+  /** Close the transport and reject any outstanding requests. */
+  async close() {
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("MCP client closed"));
+    }
+    this.pending.clear();
+    await this.transport.close();
+  }
+  // ---------- internals ----------
+  assertInitialized() {
+    if (!this.initialized) throw new Error("MCP client not initialized \u2014 call initialize() first");
+  }
+  async request(method, params) {
+    const id = this.nextId++;
+    const frame = { jsonrpc: "2.0", id, method, params };
+    const promise = new Promise((resolve2, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(
+          new Error(`MCP request ${method} (id=${id}) timed out after ${this.requestTimeoutMs}ms`)
+        );
+      }, this.requestTimeoutMs);
+      this.pending.set(id, {
+        resolve: resolve2,
+        reject,
+        timeout
+      });
+    });
+    await this.transport.send(frame);
+    return promise;
+  }
+  startReaderIfNeeded() {
+    if (this.readerStarted) return;
+    this.readerStarted = true;
+    void this.readLoop();
+  }
+  async readLoop() {
+    try {
+      for await (const msg of this.transport.messages()) {
+        this.dispatch(msg);
+      }
+    } catch (err) {
+      for (const [, pending] of this.pending) {
+        clearTimeout(pending.timeout);
+        pending.reject(err);
+      }
+      this.pending.clear();
+    }
+  }
+  dispatch(msg) {
+    if (!("id" in msg) || msg.id === null || msg.id === void 0) return;
+    if (!("result" in msg) && !("error" in msg)) return;
+    const pending = this.pending.get(msg.id);
+    if (!pending) return;
+    this.pending.delete(msg.id);
+    clearTimeout(pending.timeout);
+    const resp = msg;
+    if (isJsonRpcError(resp)) {
+      pending.reject(new Error(`MCP ${resp.error.code}: ${resp.error.message}`));
+    } else {
+      pending.resolve(resp.result);
+    }
+  }
+};
+
+// src/mcp/stdio.ts
+import { spawn } from "child_process";
+var StdioTransport = class {
+  child;
+  queue = [];
+  waiters = [];
+  closed = false;
+  stdoutBuffer = "";
+  constructor(opts) {
+    const env = opts.replaceEnv ? { ...opts.env ?? {} } : { ...process.env, ...opts.env ?? {} };
+    const shell = opts.shell ?? process.platform === "win32";
+    if (shell) {
+      const line = [
+        opts.command,
+        ...(opts.args ?? []).map((a) => quoteArg(a, process.platform === "win32"))
+      ].join(" ");
+      this.child = spawn(line, [], {
+        env,
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "inherit"],
+        shell: true
+      });
+    } else {
+      this.child = spawn(opts.command, opts.args ?? [], {
+        env,
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "inherit"]
+      });
+    }
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.onStdout(chunk));
+    this.child.on("close", () => this.onClose());
+    this.child.on("error", (err) => {
+      this.push({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32e3, message: `transport error: ${err.message}` }
+      });
+    });
+  }
+  async send(message) {
+    if (this.closed) throw new Error("MCP transport is closed");
+    return new Promise((resolve2, reject) => {
+      const line = `${JSON.stringify(message)}
+`;
+      this.child.stdin.write(line, "utf8", (err) => {
+        if (err) reject(err);
+        else resolve2();
+      });
+    });
+  }
+  async *messages() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+        continue;
+      }
+      if (this.closed) return;
+      const next = await new Promise((resolve2) => {
+        this.waiters.push(resolve2);
+      });
+      if (next === null) return;
+      yield next;
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()(null);
+    try {
+      this.child.stdin.end();
+    } catch {
+    }
+    if (this.child.exitCode === null && !this.child.killed) {
+      this.child.kill("SIGTERM");
+    }
+  }
+  /** Parse incoming stdout chunks into NDJSON messages. */
+  onStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    let newlineIdx;
+    while ((newlineIdx = this.stdoutBuffer.indexOf("\n")) !== -1) {
+      const line = this.stdoutBuffer.slice(0, newlineIdx).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newlineIdx + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line);
+        this.push(msg);
+      } catch {
+      }
+    }
+  }
+  onClose() {
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()(null);
+  }
+  push(msg) {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(msg);
+    else this.queue.push(msg);
+  }
+};
+function quoteArg(s, windows) {
+  if (!windows) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+  }
+  return `"${s.replace(/"/g, '""')}"`;
+}
+
+// src/mcp/registry.ts
+async function bridgeMcpTools(client, opts = {}) {
+  const registry = opts.registry ?? new ToolRegistry({ autoFlatten: opts.autoFlatten });
+  const prefix = opts.namePrefix ?? "";
+  const result = { registry, registeredNames: [], skipped: [] };
+  const listed = await client.listTools();
+  for (const mcpTool of listed.tools) {
+    if (!mcpTool.name) {
+      result.skipped.push({ name: "?", reason: "empty tool name" });
+      continue;
+    }
+    const registeredName = `${prefix}${mcpTool.name}`;
+    registry.register({
+      name: registeredName,
+      description: mcpTool.description ?? "",
+      parameters: mcpTool.inputSchema,
+      fn: async (args) => {
+        const toolResult = await client.callTool(mcpTool.name, args);
+        return flattenMcpResult(toolResult);
+      }
+    });
+    result.registeredNames.push(registeredName);
+  }
+  return result;
+}
+function flattenMcpResult(result) {
+  const parts = result.content.map(blockToString);
+  const joined = parts.join("\n").trim();
+  if (result.isError) {
+    return `ERROR: ${joined || "(no error message from server)"}`;
+  }
+  return joined;
+}
+function blockToString(block) {
+  if (block.type === "text") return block.text;
+  if (block.type === "image") return `[image ${block.mimeType}, ${block.data.length} chars base64]`;
+  return `[unknown block: ${JSON.stringify(block)}]`;
+}
+
 // src/config.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
@@ -1810,13 +2150,16 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.2.2";
+var VERSION = "0.3.0-alpha.2";
 export {
   AppendOnlyLog,
   CacheFirstLoop,
   DeepSeekClient,
   ImmutablePrefix,
+  MCP_PROTOCOL_VERSION,
+  McpClient,
   SessionStats,
+  StdioTransport,
   StormBreaker,
   ToolCallRepair,
   ToolRegistry,
@@ -1826,6 +2169,7 @@ export {
   aggregateBranchUsage,
   analyzeSchema,
   appendSessionMessage,
+  bridgeMcpTools,
   claudeEquivalentCost,
   computeReplayStats,
   costUsd,
@@ -1835,8 +2179,10 @@ export {
   diffTranscripts,
   emptyPlanState,
   fetchWithRetry,
+  flattenMcpResult,
   flattenSchema,
   harvest,
+  isJsonRpcError,
   isPlanStateEmpty,
   isPlausibleKey,
   listSessions,