@kody-ade/kody-engine 0.4.12 → 0.4.13

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.12",
+  version: "0.4.13",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -388,7 +388,15 @@ async function runAgent(opts) {
     ...process.env,
     SKIP_HOOKS: "1",
     HUSKY: "0",
-    CI: process.env.CI ?? "1"
+    CI: process.env.CI ?? "1",
+    // MCP servers are spawned asynchronously by the SDK. With the default
+    // non-blocking behavior, the SDK announces its tool list at session
+    // init while servers are still in `pending`, so their tools never
+    // reach the model. Block until each MCP completes its handshake (or
+    // the timeout below elapses) so the tool list is complete on first
+    // turn.
+    MCP_CONNECTION_NONBLOCKING: process.env.MCP_CONNECTION_NONBLOCKING ?? "false",
+    MCP_TIMEOUT: process.env.MCP_TIMEOUT ?? "60000"
   };
   if (opts.litellmUrl) {
     env.ANTHROPIC_BASE_URL = opts.litellmUrl;
@@ -1253,7 +1261,7 @@ function coerceBare(spec, value) {
 }
 
 // src/executor.ts
-import { execFileSync as execFileSync27, spawn as spawn4 } from "child_process";
+import { execFileSync as execFileSync27, spawn as spawn5 } from "child_process";
 import * as fs26 from "fs";
 import * as path23 from "path";
 
@@ -3904,10 +3912,14 @@ function ensurePr(opts) {
   const title = buildPrTitle(effectiveOpts.issueNumber, effectiveOpts.issueTitle, effectiveOpts.draft);
   const body = buildPrBody(effectiveOpts);
   if (existing) {
+    const stripped = existing.url.replace(/^https:\/\/github\.com\//, "");
+    const [owner, repo] = stripped.split("/");
     try {
-      gh2(["pr", "edit", String(existing.number), "--body-file", "-"], { input: body, cwd: opts.cwd });
+      gh2(["api", "--method", "PATCH", `repos/${owner}/${repo}/pulls/${existing.number}`, "-f", `body=${body}`], {
+        cwd: opts.cwd
+      });
     } catch (err) {
-      throw new Error(`gh pr edit #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw new Error(`gh api PATCH #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return { url: existing.url, number: existing.number, draft: opts.draft, action: "updated" };
   }
@@ -3966,15 +3978,19 @@ var ensureMemorizePr = async (ctx) => {
   const body = buildBody(ctx, branch, datestamp);
   const existing = findExistingPr(branch, ctx.cwd);
   if (existing) {
+    const stripped = existing.url.replace(/^https:\/\/github\.com\//, "");
+    const [owner, repo] = stripped.split("/");
     try {
-      gh2(["pr", "edit", String(existing.number), "--body-file", "-"], { input: body, cwd: ctx.cwd });
+      gh2(["api", "--method", "PATCH", `repos/${owner}/${repo}/pulls/${existing.number}`, "-f", `body=${body}`], {
+        cwd: ctx.cwd
+      });
       ctx.output.prUrl = existing.url;
       ctx.data.prResult = { url: existing.url, number: existing.number, action: "updated" };
       process.stdout.write(`[kody memorize] updated PR ${existing.url}
 `);
     } catch (err) {
       ctx.output.exitCode = 4;
-      ctx.output.reason = `gh pr edit #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`;
+      ctx.output.reason = `gh api PATCH #${existing.number} failed: ${err instanceof Error ? err.message : String(err)}`;
     }
     return;
   }
@@ -7277,6 +7293,151 @@ function sleep2(ms) {
   return new Promise((res) => setTimeout(res, ms));
 }
 
+// src/scripts/warmupMcp.ts
+import { spawn as spawn4 } from "child_process";
+var PER_SERVER_TIMEOUT_MS = 6e4;
+var PER_REQUEST_TIMEOUT_MS = 2e4;
+var warmupMcp = async (_ctx, profile) => {
+  const servers = profile.claudeCode.mcpServers ?? [];
+  if (servers.length === 0) return;
+  for (const s of servers) {
+    const start = Date.now();
+    try {
+      const result = await warmupOne(s.command, s.args ?? [], s.env);
+      const ms = Date.now() - start;
+      process.stderr.write(`[kody warmup] ${s.name}: ${result.toolCount} tools (${ms}ms)
+`);
+    } catch (err) {
+      const ms = Date.now() - start;
+      const reason = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody warmup] ${s.name} FAILED after ${ms}ms: ${reason}
+`);
+    }
+  }
+};
+async function warmupOne(command, args, env) {
+  const child = spawn4(command, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: env ? { ...process.env, ...env } : process.env
+  });
+  let stderrBuf = "";
+  child.stderr.on("data", (b) => {
+    stderrBuf += b.toString("utf8");
+    if (stderrBuf.length > 4096) stderrBuf = stderrBuf.slice(-4096);
+  });
+  const overallDeadline = Date.now() + PER_SERVER_TIMEOUT_MS;
+  const lines = lineStream(child.stdout);
+  let nextId = 1;
+  const send = (method, params) => {
+    const id = nextId++;
+    const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+    child.stdin.write(payload);
+    return id;
+  };
+  const notify = (method, params) => {
+    const payload = JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n";
+    child.stdin.write(payload);
+  };
+  const awaitResponse = async (id) => {
+    const reqDeadline = Math.min(Date.now() + PER_REQUEST_TIMEOUT_MS, overallDeadline);
+    while (Date.now() < reqDeadline) {
+      const line = await lines.next(reqDeadline - Date.now());
+      if (line === null) break;
+      let msg = null;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (msg && msg.id === id) return msg;
+    }
+    throw new Error(`request id=${id} timed out (stderr tail: ${stderrBuf.trim().slice(-300) || "(empty)"})`);
+  };
+  try {
+    const initId = send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "kody-warmup", version: "0.1.0" }
+    });
+    const initResp = await awaitResponse(initId);
+    if (initResp.error) throw new Error(`initialize error: ${initResp.error.message}`);
+    notify("notifications/initialized");
+    const listId = send("tools/list");
+    const listResp = await awaitResponse(listId);
+    if (listResp.error) throw new Error(`tools/list error: ${listResp.error.message}`);
+    const tools = listResp.result?.tools;
+    const toolCount = Array.isArray(tools) ? tools.length : 0;
+    if (toolCount === 0) throw new Error("tools/list returned 0 tools");
+    return { toolCount };
+  } finally {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, 2e3).unref();
+  }
+}
+function lineStream(stream) {
+  let buf = "";
+  const queue = [];
+  let waiter = null;
+  let ended = false;
+  const tryDeliver = () => {
+    if (waiter && queue.length > 0) {
+      const w = waiter;
+      waiter = null;
+      w(queue.shift());
+    } else if (waiter && ended) {
+      const w = waiter;
+      waiter = null;
+      w(null);
+    }
+  };
+  stream.on("data", (chunk) => {
+    buf += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, idx).replace(/\r$/, "");
+      buf = buf.slice(idx + 1);
+      if (line.length > 0) queue.push(line);
+    }
+    tryDeliver();
+  });
+  stream.on("end", () => {
+    if (buf.length > 0) {
+      queue.push(buf);
+      buf = "";
+    }
+    ended = true;
+    tryDeliver();
+  });
+  return {
+    next: (timeoutMs) => new Promise((resolve4) => {
+      if (queue.length > 0) {
+        resolve4(queue.shift());
+        return;
+      }
+      if (ended) {
+        resolve4(null);
+        return;
+      }
+      waiter = resolve4;
+      const t = setTimeout(() => {
+        if (waiter === resolve4) {
+          waiter = null;
+          resolve4(null);
+        }
+      }, Math.max(0, timeoutMs));
+      t.unref?.();
+    })
+  };
+}
+
 // src/scripts/watchStalePrsFlow.ts
 function readWatchConfig(ctx) {
   const cfg = ctx.config.watch;
@@ -7462,6 +7623,7 @@ var preflightScripts = {
   skipAgent,
   classifyByLabel,
   diagMcp,
+  warmupMcp,
   dispatchJobTicks,
   dispatchJobFileTicks
 };
@@ -7840,7 +8002,7 @@ async function runShellEntry(entry, ctx, profile) {
     env[`KODY_CFG_${k}`] = v;
   }
   const timeoutMs = resolveShellTimeoutMs(entry);
-  const child = spawn4("bash", [shellPath, ...positional], {
+  const child = spawn5("bash", [shellPath, ...positional], {
     cwd: ctx.cwd,
     env,
     stdio: ["pipe", "pipe", "pipe"],

package/dist/executables/qa-engineer/profile.json

@@ -81,6 +81,7 @@
       { "script": "discoverQaContext" },
       { "script": "loadQaGuide" },
       { "script": "loadConventions" },
+      { "script": "warmupMcp" },
       { "script": "composePrompt" }
     ],
     "postflight": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",