@kody-ade/kody-engine 0.4.41 → 0.4.42

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.41",
+  version: "0.4.42",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -1555,6 +1555,32 @@ function emitEvent(cwd, ev) {
   } catch {
   }
 }
+function readEvents(cwd, runId) {
+  const eventsPath = path7.join(cwd, ".kody", "runs", runId, "events.jsonl");
+  if (!fs8.existsSync(eventsPath)) return [];
+  const lines = fs8.readFileSync(eventsPath, "utf-8").split("\n");
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+function listRuns(cwd) {
+  const runsDir = path7.join(cwd, ".kody", "runs");
+  if (!fs8.existsSync(runsDir)) return [];
+  return fs8.readdirSync(runsDir).filter((name) => {
+    try {
+      return fs8.statSync(path7.join(runsDir, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  }).sort();
+}
 
 // src/profile.ts
 import * as fs9 from "fs";
@@ -10304,6 +10330,206 @@ ${CHAT_HELP}`);
   }
 }
 
+// src/stats.ts
+function parseStatsArgs(argv) {
+  const out = { cwd: process.cwd() };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--json") out.asJson = true;
+    else if (a === "--cwd" && argv[i + 1]) {
+      out.cwd = argv[++i];
+    } else if (a === "--since" && argv[i + 1]) {
+      out.sinceMs = parseDuration(argv[++i]);
+    } else if (a === "--run" && argv[i + 1]) {
+      out.runId = argv[++i];
+    }
+  }
+  return out;
+}
+function parseDuration(s) {
+  const m = /^(\d+)\s*([smhd])$/i.exec(s.trim());
+  if (!m) return void 0;
+  const n = Number.parseInt(m[1], 10);
+  const unit = m[2].toLowerCase();
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * mult;
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.floor(p / 100 * sorted.length)));
+  return sorted[idx];
+}
+function summarizeRun(events) {
+  if (events.length === 0) return null;
+  const sorted = [...events].sort((a, b) => a.ts.localeCompare(b.ts));
+  const start = sorted.find((e) => e.kind === "stage_start");
+  const ends = sorted.filter((e) => e.kind === "stage_end");
+  const lastEnd = ends.length > 0 ? ends[ends.length - 1] : void 0;
+  const startedAt = start?.ts ?? sorted[0].ts;
+  const endedAt = lastEnd?.ts ?? sorted[sorted.length - 1].ts;
+  const durationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  const exitCodeRaw = lastEnd?.meta?.exitCode;
+  const exitCode = typeof exitCodeRaw === "number" ? exitCodeRaw : null;
+  const executables = Array.from(new Set(sorted.map((e) => e.executable)));
+  let tIn = 0;
+  let tOut = 0;
+  let tCacheR = 0;
+  for (const ev of sorted) {
+    if (ev.kind !== "agent_end") continue;
+    const tokens = ev.meta?.tokens;
+    if (tokens) {
+      tIn += Number(tokens.input ?? 0);
+      tOut += Number(tokens.output ?? 0);
+      tCacheR += Number(tokens.cacheRead ?? 0);
+    }
+  }
+  return {
+    runId: sorted[0].runId,
+    startedAt,
+    endedAt,
+    durationMs,
+    executables,
+    exitCode,
+    ok: exitCode === 0,
+    totalInputTokens: tIn,
+    totalOutputTokens: tOut,
+    totalCacheReadTokens: tCacheR
+  };
+}
+function rollupByExecutable(events) {
+  const byExec = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind !== "stage_end") continue;
+    if (!byExec.has(ev.executable)) byExec.set(ev.executable, []);
+    byExec.get(ev.executable).push(ev);
+  }
+  const rollups = [];
+  for (const [executable, stageEnds] of byExec) {
+    const durations = stageEnds.map((e) => e.durationMs ?? 0).filter((d) => d > 0).sort((a, b) => a - b);
+    const ok = stageEnds.filter((e) => e.outcome === "ok").length;
+    const failed = stageEnds.filter((e) => e.outcome === "failed").length;
+    let tIn = 0;
+    let tOut = 0;
+    let tCacheR = 0;
+    let tCacheC = 0;
+    for (const ev of events) {
+      if (ev.kind !== "agent_end") continue;
+      if (ev.executable !== executable) continue;
+      const tokens = ev.meta?.tokens;
+      if (tokens) {
+        tIn += Number(tokens.input ?? 0);
+        tOut += Number(tokens.output ?? 0);
+        tCacheR += Number(tokens.cacheRead ?? 0);
+        tCacheC += Number(tokens.cacheCreate ?? 0);
+      }
+    }
+    const mean = durations.length > 0 ? durations.reduce((s, n) => s + n, 0) / durations.length : 0;
+    rollups.push({
+      executable,
+      runs: stageEnds.length,
+      ok,
+      failed,
+      p50Ms: percentile(durations, 50),
+      p95Ms: percentile(durations, 95),
+      meanMs: Math.round(mean),
+      totalInputTokens: tIn,
+      totalOutputTokens: tOut,
+      totalCacheReadTokens: tCacheR,
+      totalCacheCreateTokens: tCacheC
+    });
+  }
+  rollups.sort((a, b) => b.runs - a.runs);
+  return rollups;
+}
+async function runStats(argv) {
+  const opts = parseStatsArgs(argv);
+  const runIds = opts.runId ? [opts.runId] : listRuns(opts.cwd);
+  if (runIds.length === 0) {
+    process.stdout.write(`no runs found under ${opts.cwd}/.kody/runs/
+`);
+    return 0;
+  }
+  const cutoff = opts.sinceMs ? Date.now() - opts.sinceMs : null;
+  const allEvents = [];
+  const runSummaries = [];
+  for (const id of runIds) {
+    const events = readEvents(opts.cwd, id);
+    if (events.length === 0) continue;
+    const summary = summarizeRun(events);
+    if (!summary) continue;
+    if (cutoff && new Date(summary.startedAt).getTime() < cutoff) continue;
+    allEvents.push(...events);
+    runSummaries.push(summary);
+  }
+  if (runSummaries.length === 0) {
+    process.stdout.write("no runs in the requested window\n");
+    return 0;
+  }
+  const byExec = rollupByExecutable(allEvents);
+  if (opts.asJson) {
+    process.stdout.write(`${JSON.stringify({ runs: runSummaries, byExecutable: byExec }, null, 2)}
+`);
+    return 0;
+  }
+  printReport(runSummaries, byExec);
+  return 0;
+}
+function printReport(runs, rollups) {
+  const totalRuns = runs.length;
+  const okRuns = runs.filter((r) => r.ok).length;
+  const okPct = totalRuns > 0 ? (okRuns / totalRuns * 100).toFixed(1) : "\u2014";
+  const durations = runs.map((r) => r.durationMs).sort((a, b) => a - b);
+  const meanMs = durations.length > 0 ? durations.reduce((s, n) => s + n, 0) / durations.length : 0;
+  process.stdout.write(`
+Kody run statistics \u2014 ${totalRuns} runs
+`);
+  process.stdout.write(`  success rate     : ${okRuns}/${totalRuns} (${okPct}%)
+`);
+  process.stdout.write(`  mean wall-clock  : ${formatMs(meanMs)}
+`);
+  process.stdout.write(`  p50 wall-clock   : ${formatMs(percentile(durations, 50))}
+`);
+  process.stdout.write(`  p95 wall-clock   : ${formatMs(percentile(durations, 95))}
+`);
+  const totalIn = runs.reduce((s, r) => s + r.totalInputTokens, 0);
+  const totalOut = runs.reduce((s, r) => s + r.totalOutputTokens, 0);
+  const totalCacheR = runs.reduce((s, r) => s + r.totalCacheReadTokens, 0);
+  process.stdout.write(`  total tokens     : ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out / ${totalCacheR.toLocaleString()} cache-read
+`);
+  process.stdout.write(`
+Per-executable (stage_end events)
+`);
+  const headers = ["executable", "runs", "ok", "failed", "p50", "p95", "mean", "tok-in", "tok-out", "cache-r"];
+  const widths = [22, 6, 6, 7, 9, 9, 9, 10, 10, 10];
+  process.stdout.write(headers.map((h, i) => h.padEnd(widths[i])).join("") + "\n");
+  process.stdout.write(widths.map((w) => "-".repeat(w - 1) + " ").join("") + "\n");
+  for (const r of rollups) {
+    const row = [
+      r.executable,
+      String(r.runs),
+      String(r.ok),
+      String(r.failed),
+      formatMs(r.p50Ms),
+      formatMs(r.p95Ms),
+      formatMs(r.meanMs),
+      r.totalInputTokens.toLocaleString(),
+      r.totalOutputTokens.toLocaleString(),
+      r.totalCacheReadTokens.toLocaleString()
+    ];
+    process.stdout.write(row.map((c, i) => c.padEnd(widths[i])).join("") + "\n");
+  }
+  process.stdout.write("\n");
+}
+function formatMs(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "\u2014";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = seconds / 60;
+  if (minutes < 60) return `${minutes.toFixed(1)}m`;
+  return `${(minutes / 60).toFixed(2)}h`;
+}
+
 // src/entry.ts
 var HELP_TEXT = `kody \u2014 single-session autonomous engineer
 
@@ -10316,6 +10542,7 @@ Usage:
   kody <other>                                [--cwd <path>] [--verbose|--quiet]
   kody ci      --issue <N> [preflight flags \u2014 see: kody ci --help]
   kody chat    [chat flags \u2014 see: kody chat --help]
+  kody stats   [--since 7d|--run <id>|--json|--cwd <path>]
   kody help
   kody version
 
@@ -10349,6 +10576,9 @@ function parseArgs(argv) {
   if (cmd === "chat") {
     return { ...result, command: "chat", chatArgv: argv.slice(1) };
   }
+  if (cmd === "stats") {
+    return { ...result, command: "stats", statsArgv: argv.slice(1) };
+  }
   if (hasExecutable(cmd)) {
     result.command = "__executable__";
     result.executableName = cmd;
@@ -10359,7 +10589,7 @@ function parseArgs(argv) {
     return result;
   }
   const discovered = listExecutables().map((e) => e.name);
-  const available = ["ci", "help", "version", ...discovered];
+  const available = ["ci", "chat", "stats", "help", "version", ...discovered];
   result.errors.push(`unknown command: ${cmd} (available: ${available.join(", ")})`);
   return result;
 }
@@ -10401,6 +10631,18 @@ ${HELP_TEXT}`);
       process.stderr.write(`[kody] fatal: ${msg}
 `);
       if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
+`);
+      return 99;
+    }
+  }
+  if (args.command === "stats") {
+    try {
+      return await runStats(args.statsArgv ?? []);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[kody] fatal: ${msg}
+`);
+      if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}
 `);
       return 99;
     }

package/package.json

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