@kody-ade/kody-engine 0.2.5 → 0.2.6

package/dist/bin/kody2.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.2.5",
+  version: "0.2.6",
   description: "kody2 \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -81,7 +81,7 @@ function loadConfig(projectDir = process.cwd()) {
     throw new Error(`kody.config.json is invalid JSON: ${msg}`);
   }
   const quality = raw.quality ?? {};
-  const git3 = raw.git ?? {};
+  const git4 = raw.git ?? {};
   const github = raw.github ?? {};
   const agent = raw.agent ?? {};
   if (!agent.model || typeof agent.model !== "string") {
@@ -97,7 +97,7 @@ function loadConfig(projectDir = process.cwd()) {
       testUnit: typeof quality.testUnit === "string" ? quality.testUnit : ""
     },
     git: {
-      defaultBranch: typeof git3.defaultBranch === "string" ? git3.defaultBranch : "main"
+      defaultBranch: typeof git4.defaultBranch === "string" ? git4.defaultBranch : "main"
     },
     github: {
       owner: String(github.owner),
@@ -107,9 +107,23 @@ function loadConfig(projectDir = process.cwd()) {
       model: String(agent.model)
     },
     issueContext: parseIssueContext(raw.issueContext),
-    testRequirements: parseTestRequirements(raw.testRequirements)
+    testRequirements: parseTestRequirements(raw.testRequirements),
+    release: parseReleaseConfig(raw.release)
   };
 }
+function parseReleaseConfig(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const out = {};
+  if (Array.isArray(r.versionFiles)) out.versionFiles = r.versionFiles.filter((f) => typeof f === "string");
+  if (typeof r.publishCommand === "string") out.publishCommand = r.publishCommand;
+  if (typeof r.notifyCommand === "string") out.notifyCommand = r.notifyCommand;
+  if (typeof r.e2eCommand === "string") out.e2eCommand = r.e2eCommand;
+  if (typeof r.draftRelease === "boolean") out.draftRelease = r.draftRelease;
+  if (typeof r.releaseBranch === "string") out.releaseBranch = r.releaseBranch;
+  if (typeof r.timeoutMs === "number" && r.timeoutMs > 0) out.timeoutMs = Math.floor(r.timeoutMs);
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function parseIssueContext(raw) {
   if (!raw || typeof raw !== "object") return void 0;
   const r = raw;
@@ -137,8 +151,8 @@ function getAnthropicApiKeyOrDummy() {
 }
 
 // src/executor.ts
-import * as fs11 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 
 // src/agent.ts
 import * as fs2 from "fs";
@@ -1947,8 +1961,310 @@ REVIEW_POSTED=https://github.com/${ctx.config.github.owner}/${ctx.config.github.
 `);
 };
 
+// src/scripts/releaseFlow.ts
+import { execFileSync as execFileSync10, spawnSync } from "child_process";
+import * as fs10 from "fs";
+import * as path9 from "path";
+function bumpVersion(current, bump) {
+  const m = current.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+  if (!m) throw new Error(`cannot parse version '${current}' (expected x.y.z[-suffix])`);
+  let [major, minor, patch] = [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
+  if (bump === "major") {
+    major++;
+    minor = 0;
+    patch = 0;
+  } else if (bump === "minor") {
+    minor++;
+    patch = 0;
+  } else patch++;
+  return `${major}.${minor}.${patch}`;
+}
+function updateVersionInFile(file, newVersion, cwd) {
+  const abs = path9.join(cwd, file);
+  if (!fs10.existsSync(abs)) return false;
+  const content = fs10.readFileSync(abs, "utf-8");
+  const updated = content.replace(/"version"\s*:\s*"[^"]+"/, `"version": "${newVersion}"`);
+  if (updated === content) return false;
+  fs10.writeFileSync(abs, updated);
+  return true;
+}
+function generateChangelog(cwd, newVersion, lastTag) {
+  const range = lastTag ? `${lastTag}..HEAD` : "HEAD";
+  let log = "";
+  try {
+    log = execFileSync10("git", ["log", range, "--pretty=format:%s||%h", "--no-merges"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+  }
+  const commits = log.split("\n").filter((l) => l.length > 0).map((line) => {
+    const [subject, sha] = line.split("||");
+    return { subject: subject ?? "", sha: sha ?? "" };
+  }).filter((c) => !/^chore:\s*release\s+v\d/i.test(c.subject));
+  const groups = { feat: [], fix: [], perf: [], refactor: [], docs: [], chore: [], other: [] };
+  for (const c of commits) {
+    const m = c.subject.match(/^(\w+)(?:\(.*?\))?\s*:\s*(.+)$/);
+    const type = m?.[1]?.toLowerCase() ?? "other";
+    const msg = m?.[2] ?? c.subject;
+    const bucket = groups[type] ?? groups.other;
+    bucket.push(`- ${msg} (${c.sha})`);
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const parts = [`## v${newVersion} \u2014 ${date}`, ""];
+  const labels = [
+    ["feat", "Features"],
+    ["fix", "Fixes"],
+    ["perf", "Performance"],
+    ["refactor", "Refactoring"],
+    ["docs", "Docs"],
+    ["chore", "Chores"],
+    ["other", "Other"]
+  ];
+  for (const [key, label] of labels) {
+    const items = groups[key];
+    if (!items || items.length === 0) continue;
+    parts.push(`### ${label}`);
+    parts.push(...items);
+    parts.push("");
+  }
+  if (parts.length === 2) parts.push("_No notable commits since the last release._", "");
+  return parts.join("\n");
+}
+function prependChangelog(cwd, entry) {
+  const p = path9.join(cwd, "CHANGELOG.md");
+  const header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n";
+  if (fs10.existsSync(p)) {
+    const prior = fs10.readFileSync(p, "utf-8");
+    if (/^#\s*Changelog\b/m.test(prior)) {
+      const idx = prior.indexOf("\n", prior.indexOf("# Changelog"));
+      fs10.writeFileSync(p, `${prior.slice(0, idx + 1)}
+${entry}${prior.slice(idx + 1)}`);
+    } else {
+      fs10.writeFileSync(p, `${header}${entry}${prior}`);
+    }
+  } else {
+    fs10.writeFileSync(p, `${header}${entry}`);
+  }
+}
+function git3(args, cwd, timeout = 6e4) {
+  return execFileSync10("git", args, {
+    encoding: "utf-8",
+    timeout,
+    cwd,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" },
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function lastReleaseTag(cwd) {
+  try {
+    return git3(["describe", "--tags", "--abbrev=0", "--match", "v*"], cwd);
+  } catch {
+    return null;
+  }
+}
+function runShell(cmd, cwd, timeoutMs) {
+  const r = spawnSync(cmd, {
+    cwd,
+    shell: true,
+    env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" },
+    encoding: "utf-8",
+    timeout: timeoutMs
+  });
+  return { exitCode: r.status ?? -1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+var releaseFlow = async (ctx) => {
+  const mode = ctx.args.mode ?? "prepare";
+  const bump = ctx.args.bump ?? "patch";
+  const dryRun = ctx.args["dry-run"] === true || ctx.args.dryRun === true;
+  const cwd = ctx.cwd;
+  const releaseCfg = ctx.config.release ?? {};
+  const versionFiles = releaseCfg.versionFiles && releaseCfg.versionFiles.length > 0 ? releaseCfg.versionFiles : ["package.json"];
+  const timeoutMs = releaseCfg.timeoutMs ?? 6e5;
+  ctx.skipAgent = true;
+  if (mode === "prepare") {
+    await runPrepare({ cwd, bump, dryRun, versionFiles, ctx });
+    return;
+  }
+  if (mode === "finalize") {
+    await runFinalize({ cwd, dryRun, timeoutMs, releaseCfg, ctx });
+    return;
+  }
+  ctx.output.exitCode = 64;
+  ctx.output.reason = `release: unknown mode '${mode}'`;
+};
+async function runPrepare(args) {
+  const { cwd, bump, dryRun, versionFiles, ctx } = args;
+  const pkgPath = path9.join(cwd, "package.json");
+  if (!fs10.existsSync(pkgPath)) {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = "release prepare: package.json not found";
+    return;
+  }
+  const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  if (typeof pkg.version !== "string") {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = "release prepare: package.json has no version";
+    return;
+  }
+  const oldVersion = pkg.version;
+  const newVersion = bumpVersion(oldVersion, bump);
+  const tag = `v${newVersion}`;
+  process.stdout.write(`\u2192 release prepare: ${oldVersion} \u2192 ${newVersion} (${bump})
+`);
+  if (dryRun) {
+    ctx.output.exitCode = 0;
+    ctx.output.reason = `dry-run \u2014 would bump to ${newVersion}`;
+    process.stdout.write(`RELEASE_PLAN=bump=${newVersion} tag=${tag}
+`);
+    return;
+  }
+  const touched = [];
+  for (const f of versionFiles) {
+    if (updateVersionInFile(f, newVersion, cwd)) touched.push(f);
+  }
+  if (touched.length === 0) {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `release prepare: no version strings updated (files: ${versionFiles.join(", ")})`;
+    return;
+  }
+  process.stdout.write(`  wrote    ${touched.join(", ")}
+`);
+  const entry = generateChangelog(cwd, newVersion, lastReleaseTag(cwd));
+  prependChangelog(cwd, entry);
+  process.stdout.write(`  wrote    CHANGELOG.md
+`);
+  const releaseBranch = `release/${tag}`;
+  try {
+    git3(["checkout", "-b", releaseBranch], cwd);
+    for (const f of [...touched, "CHANGELOG.md"]) git3(["add", "--", f], cwd);
+    git3(["commit", "--no-gpg-sign", "-m", `chore: release ${tag}`], cwd);
+    git3(["push", "-u", "origin", releaseBranch], cwd, 12e4);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.output.exitCode = 4;
+    ctx.output.reason = `release prepare: git commit/push failed: ${msg}`;
+    return;
+  }
+  const base = ctx.config.git.defaultBranch;
+  const title = `chore: release ${tag}`;
+  const body = `Automated release PR opened by kody2.
+
+${entry}
+
+Merge this and then run \`kody2 release --mode finalize\`.`;
+  let prUrl = "";
+  try {
+    prUrl = gh(
+      ["pr", "create", "--head", releaseBranch, "--base", base, "--title", title, "--body-file", "-"],
+      { input: body, cwd }
+    ).trim();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.output.exitCode = 4;
+    ctx.output.reason = `release prepare: gh pr create failed: ${msg}`;
+    return;
+  }
+  ctx.output.prUrl = prUrl;
+  ctx.output.exitCode = 0;
+  process.stdout.write(`RELEASE_PR=${prUrl}
+`);
+}
+async function runFinalize(args) {
+  const { cwd, dryRun, timeoutMs, releaseCfg, ctx } = args;
+  const pkgPath = path9.join(cwd, "package.json");
+  const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  if (typeof pkg.version !== "string") {
+    ctx.output.exitCode = 99;
+    ctx.output.reason = "release finalize: package.json has no version";
+    return;
+  }
+  const version = pkg.version;
+  const tag = `v${version}`;
+  process.stdout.write(`\u2192 release finalize: ${tag}
+`);
+  try {
+    git3(["rev-parse", "--verify", tag], cwd);
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `release finalize: tag ${tag} already exists`;
+    return;
+  } catch {
+  }
+  if (dryRun) {
+    ctx.output.exitCode = 0;
+    ctx.output.reason = `dry-run \u2014 would tag + publish ${tag}`;
+    return;
+  }
+  if (releaseCfg.e2eCommand && releaseCfg.e2eCommand.trim().length > 0) {
+    const cmd = releaseCfg.e2eCommand.replace(/\$VERSION/g, version);
+    process.stdout.write(`  E2E gate: ${cmd}
+`);
+    const r = runShell(cmd, cwd, timeoutMs);
+    if (r.exitCode !== 0) {
+      ctx.output.exitCode = 2;
+      ctx.output.reason = `release finalize: E2E gate failed (exit ${r.exitCode}): ${truncate2(r.stderr, 600)}`;
+      return;
+    }
+  }
+  try {
+    git3(["tag", "-a", tag, "-m", `Release ${tag}`], cwd);
+    git3(["push", "origin", tag], cwd, 12e4);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.output.exitCode = 4;
+    ctx.output.reason = `release finalize: tag/push failed: ${msg}`;
+    return;
+  }
+  let publishStatus = "skipped";
+  if (releaseCfg.publishCommand && releaseCfg.publishCommand.trim().length > 0) {
+    const cmd = releaseCfg.publishCommand.replace(/\$VERSION/g, version);
+    process.stdout.write(`  publish: ${cmd}
+`);
+    const r = runShell(cmd, cwd, timeoutMs);
+    publishStatus = r.exitCode === 0 ? "ok" : "failed";
+    if (r.exitCode !== 0) {
+      process.stderr.write(`[kody2 release] publishCommand exit ${r.exitCode}
+${truncate2(r.stderr, 2e3)}
+`);
+    }
+  }
+  let releaseUrl = "";
+  try {
+    const releaseArgs = [
+      "release",
+      "create",
+      tag,
+      "--title",
+      tag,
+      "--notes",
+      `Release ${tag} \u2014 automated by kody2.`
+    ];
+    if (releaseCfg.draftRelease) releaseArgs.push("--draft");
+    releaseUrl = gh(releaseArgs, { cwd }).trim();
+  } catch (err) {
+    process.stderr.write(`[kody2 release] gh release create failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  if (releaseCfg.notifyCommand && releaseCfg.notifyCommand.trim().length > 0) {
+    const cmd = releaseCfg.notifyCommand.replace(/\$VERSION/g, version);
+    runShell(cmd, cwd, timeoutMs);
+  }
+  if (releaseUrl) ctx.output.prUrl = releaseUrl;
+  if (publishStatus === "failed") {
+    ctx.output.exitCode = 1;
+    ctx.output.reason = `release finalize: tag + gh release created, but publishCommand failed`;
+    return;
+  }
+  ctx.output.exitCode = 0;
+  process.stdout.write(`RELEASE_TAG=${tag}
+`);
+  if (releaseUrl) process.stdout.write(`RELEASE_URL=${releaseUrl}
+`);
+}
+
 // src/scripts/resolveFlow.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 var CONFLICT_DIFF_MAX_BYTES = 4e4;
 var resolveFlow = async (ctx) => {
   const prNumber = ctx.args.pr;
@@ -2000,7 +2316,7 @@ var resolveFlow = async (ctx) => {
 };
 function getConflictedFiles(cwd) {
   try {
-    const out = execFileSync10("git", ["diff", "--name-only", "--diff-filter=U"], {
+    const out = execFileSync11("git", ["diff", "--name-only", "--diff-filter=U"], {
       encoding: "utf-8",
       cwd,
       env: { ...process.env, HUSKY: "0" }
@@ -2015,7 +2331,7 @@ function getConflictMarkersPreview(files, cwd, maxBytes = CONFLICT_DIFF_MAX_BYTE
   let total = 0;
   for (const f of files) {
     try {
-      const content = execFileSync10("cat", [f], { encoding: "utf-8", cwd }).toString();
+      const content = execFileSync11("cat", [f], { encoding: "utf-8", cwd }).toString();
       const snippet = `### ${f}
 
 \`\`\`
@@ -2180,7 +2496,7 @@ var verify = async (ctx) => {
 };
 
 // src/scripts/writeRunSummary.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 var writeRunSummary = async (ctx) => {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
@@ -2202,7 +2518,7 @@ var writeRunSummary = async (ctx) => {
   if (reason) lines.push(`- **Reason:** ${reason}`);
   lines.push("");
   try {
-    fs10.appendFileSync(summaryPath, `${lines.join("\n")}
+    fs11.appendFileSync(summaryPath, `${lines.join("\n")}
 `);
   } catch {
   }
@@ -2216,6 +2532,7 @@ var preflightScripts = {
   resolveFlow,
   reviewFlow,
   initFlow,
+  releaseFlow,
   loadConventions,
   loadCoverageRules,
   composePrompt
@@ -2236,7 +2553,7 @@ var allScriptNames = /* @__PURE__ */ new Set([
 ]);
 
 // src/tools.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 function verifyCliTools(tools, cwd) {
   const out = [];
   for (const t of tools) out.push(verifyOne(t, cwd));
@@ -2252,24 +2569,24 @@ function firstRequiredFailure(results, tools) {
 }
 function verifyOne(tool, cwd) {
   const result = { name: tool.name, present: false, verified: false };
-  let present = runShell(tool.install.checkCommand, cwd);
+  let present = runShell2(tool.install.checkCommand, cwd);
   if (!present && tool.install.installCommand) {
-    runShell(tool.install.installCommand, cwd, 12e4);
-    present = runShell(tool.install.checkCommand, cwd);
+    runShell2(tool.install.installCommand, cwd, 12e4);
+    present = runShell2(tool.install.checkCommand, cwd);
   }
   result.present = present;
   if (!present) {
     result.error = `tool "${tool.name}" not on PATH (check: ${tool.install.checkCommand})`;
     return result;
   }
-  const verified = runShell(tool.verify, cwd);
+  const verified = runShell2(tool.verify, cwd);
   result.verified = verified;
   if (!verified) result.error = `tool "${tool.name}" failed verify: ${tool.verify}`;
   return result;
 }
-function runShell(cmd, cwd, timeoutMs = 3e4) {
+function runShell2(cmd, cwd, timeoutMs = 3e4) {
   try {
-    execFileSync11("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
+    execFileSync12("sh", ["-c", cmd], { cwd, stdio: "pipe", timeout: timeoutMs });
     return true;
   } catch {
     return false;
@@ -2320,7 +2637,7 @@ async function runExecutable(profileName, input) {
     data: {},
     output: { exitCode: 0 }
   };
-  const ndjsonDir = path9.join(input.cwd, ".kody2");
+  const ndjsonDir = path10.join(input.cwd, ".kody2");
   const invokeAgent = async (prompt) => runAgent({
     prompt,
     model,
@@ -2379,17 +2696,17 @@ async function runExecutable(profileName, input) {
   }
 }
 function resolveProfilePath(profileName) {
-  const here = path9.dirname(new URL(import.meta.url).pathname);
+  const here = path10.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path9.join(here, "executables", profileName, "profile.json"),
+    path10.join(here, "executables", profileName, "profile.json"),
     // same-dir sibling (dev)
-    path9.join(here, "..", "executables", profileName, "profile.json"),
+    path10.join(here, "..", "executables", profileName, "profile.json"),
     // up one (prod: dist/bin → dist/executables)
-    path9.join(here, "..", "src", "executables", profileName, "profile.json")
+    path10.join(here, "..", "src", "executables", profileName, "profile.json")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs11.existsSync(c)) return c;
+    if (fs12.existsSync(c)) return c;
   }
   return candidates[0];
 }
@@ -2467,12 +2784,12 @@ function finish(out) {
 }
 
 // src/kody2-cli.ts
-import { execFileSync as execFileSync12 } from "child_process";
-import * as fs13 from "fs";
-import * as path10 from "path";
+import { execFileSync as execFileSync13 } from "child_process";
+import * as fs14 from "fs";
+import * as path11 from "path";
 
 // src/dispatch.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 function autoDispatch(explicit) {
   if (explicit?.mode && explicit.target) {
     return {
@@ -2482,10 +2799,10 @@ function autoDispatch(explicit) {
   }
   const eventName = process.env.GITHUB_EVENT_NAME;
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventName || !eventPath || !fs12.existsSync(eventPath)) return null;
+  if (!eventName || !eventPath || !fs13.existsSync(eventPath)) return null;
   let event = {};
   try {
-    event = JSON.parse(fs12.readFileSync(eventPath, "utf-8"));
+    event = JSON.parse(fs13.readFileSync(eventPath, "utf-8"));
   } catch {
     return null;
   }
@@ -2605,14 +2922,14 @@ function resolveAuthToken(env = process.env) {
   return token;
 }
 function detectPackageManager2(cwd) {
-  if (fs13.existsSync(path10.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs13.existsSync(path10.join(cwd, "yarn.lock"))) return "yarn";
-  if (fs13.existsSync(path10.join(cwd, "bun.lockb"))) return "bun";
+  if (fs14.existsSync(path11.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs14.existsSync(path11.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs14.existsSync(path11.join(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function shellOut(cmd, args, cwd, stream = true) {
   try {
-    execFileSync12(cmd, args, {
+    execFileSync13(cmd, args, {
       cwd,
       stdio: stream ? "inherit" : "pipe",
       env: { ...process.env, HUSKY: "0", SKIP_HOOKS: "1", CI: process.env.CI ?? "1" }
@@ -2625,7 +2942,7 @@ function shellOut(cmd, args, cwd, stream = true) {
 }
 function isOnPath(bin) {
   try {
-    execFileSync12("which", [bin], { stdio: "pipe" });
+    execFileSync13("which", [bin], { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -2659,7 +2976,7 @@ function installLitellmIfNeeded(cwd) {
   } catch {
   }
   try {
-    execFileSync12("python3", ["-c", "import litellm"], { stdio: "pipe" });
+    execFileSync13("python3", ["-c", "import litellm"], { stdio: "pipe" });
     process.stdout.write("\u2192 kody2: litellm already installed\n");
     return 0;
   } catch {
@@ -2669,26 +2986,26 @@ function installLitellmIfNeeded(cwd) {
 }
 function configureGitIdentity(cwd) {
   try {
-    const name = execFileSync12("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
+    const name = execFileSync13("git", ["config", "user.name"], { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
     if (name) return;
   } catch {
   }
   try {
-    execFileSync12("git", ["config", "user.name", "kody2-bot"], { cwd, stdio: "pipe" });
+    execFileSync13("git", ["config", "user.name", "kody2-bot"], { cwd, stdio: "pipe" });
   } catch {
   }
   try {
-    execFileSync12("git", ["config", "user.email", "kody2-bot@users.noreply.github.com"], { cwd, stdio: "pipe" });
+    execFileSync13("git", ["config", "user.email", "kody2-bot@users.noreply.github.com"], { cwd, stdio: "pipe" });
   } catch {
   }
 }
 function postFailureTail(issueNumber, cwd, reason) {
   if (!issueNumber) return;
-  const logPath = path10.join(cwd, ".kody2", "last-run.jsonl");
+  const logPath = path11.join(cwd, ".kody2", "last-run.jsonl");
   let tail = "";
   try {
-    if (fs13.existsSync(logPath)) {
-      const content = fs13.readFileSync(logPath, "utf-8");
+    if (fs14.existsSync(logPath)) {
+      const content = fs14.readFileSync(logPath, "utf-8");
       tail = content.slice(-3e3);
     }
   } catch {
@@ -2725,7 +3042,7 @@ async function runCi(argv) {
 ${CI_HELP}`);
     return 64;
   }
-  const cwd = args.cwd ? path10.resolve(args.cwd) : process.cwd();
+  const cwd = args.cwd ? path11.resolve(args.cwd) : process.cwd();
   const dispatch = autoFallback ?? {
     mode: "run",
     target: args.issueNumber,
@@ -2801,31 +3118,31 @@ ${CI_HELP}`);
 }
 
 // src/registry.ts
-import * as fs14 from "fs";
-import * as path11 from "path";
+import * as fs15 from "fs";
+import * as path12 from "path";
 function getExecutablesRoot() {
-  const here = path11.dirname(new URL(import.meta.url).pathname);
+  const here = path12.dirname(new URL(import.meta.url).pathname);
   const candidates = [
-    path11.join(here, "executables"),
+    path12.join(here, "executables"),
     // dev: src/
-    path11.join(here, "..", "executables"),
+    path12.join(here, "..", "executables"),
     // built: dist/bin → dist/executables
-    path11.join(here, "..", "src", "executables")
+    path12.join(here, "..", "src", "executables")
     // fallback
   ];
   for (const c of candidates) {
-    if (fs14.existsSync(c) && fs14.statSync(c).isDirectory()) return c;
+    if (fs15.existsSync(c) && fs15.statSync(c).isDirectory()) return c;
   }
   return candidates[0];
 }
 function listExecutables(root = getExecutablesRoot()) {
-  if (!fs14.existsSync(root)) return [];
-  const entries = fs14.readdirSync(root, { withFileTypes: true });
+  if (!fs15.existsSync(root)) return [];
+  const entries = fs15.readdirSync(root, { withFileTypes: true });
   const out = [];
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const profilePath = path11.join(root, ent.name, "profile.json");
-    if (fs14.existsSync(profilePath) && fs14.statSync(profilePath).isFile()) {
+    const profilePath = path12.join(root, ent.name, "profile.json");
+    if (fs15.existsSync(profilePath) && fs15.statSync(profilePath).isFile()) {
       out.push({ name: ent.name, profilePath });
     }
   }
@@ -2833,8 +3150,8 @@ function listExecutables(root = getExecutablesRoot()) {
 }
 function hasExecutable(name, root = getExecutablesRoot()) {
   if (!isSafeName(name)) return false;
-  const profilePath = path11.join(root, name, "profile.json");
-  return fs14.existsSync(profilePath) && fs14.statSync(profilePath).isFile();
+  const profilePath = path12.join(root, name, "profile.json");
+  return fs15.existsSync(profilePath) && fs15.statSync(profilePath).isFile();
 }
 function isSafeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name) && !name.includes("..");

package/dist/executables/release/profile.json

@@ -0,0 +1,53 @@
+{
+  "name": "release",
+  "describe": "Version bump + changelog + release PR (prepare), or tag + publish + GH release (finalize). No agent.",
+
+  "inputs": [
+    {
+      "name": "mode",
+      "flag": "--mode",
+      "type": "enum",
+      "values": ["prepare", "finalize"],
+      "required": false,
+      "describe": "`prepare` (default): bump + changelog + release PR. `finalize`: E2E gate + tag + publish + GH release."
+    },
+    {
+      "name": "bump",
+      "flag": "--bump",
+      "type": "enum",
+      "values": ["patch", "minor", "major"],
+      "required": false,
+      "describe": "Version bump when mode=prepare (ignored in finalize). Default patch."
+    },
+    {
+      "name": "dry-run",
+      "flag": "--dry-run",
+      "type": "bool",
+      "required": false,
+      "describe": "Print plan without writing files, creating PRs, tagging, or publishing."
+    }
+  ],
+
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "acceptEdits",
+    "maxTurns": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": { "PreToolUse": [], "PostToolUse": [], "Stop": [] },
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+
+  "cliTools": [],
+
+  "scripts": {
+    "preflight": [
+      { "script": "releaseFlow" }
+    ],
+    "postflight": []
+  }
+}

package/package.json

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