@flumecode/runner 0.1.0 → 0.3.0

package/README.md

@@ -45,7 +45,8 @@ pnpm --filter @flumecode/runner dev login   # or: dev start
 
 `pnpm --filter @flumecode/runner build` produces the published single-file bundle
 (`dist/cli.js`); it is published to npm by the `release-runner` GitHub workflow
-when a `runner-v*` tag is pushed.
+when a GitHub Release is created (publishing the version in `package.json`, and
+skipping if that version is already on npm).
 
 ## What a job does
 

package/dist/cli.js

@@ -175,6 +175,9 @@ var stepSchema = z2.object({
   files: z2.array(z2.string()).optional().describe("Affected file paths.")
 });
 var planInputSchema = {
+  title: z2.string().min(1).max(120).describe(
+    "A concise, descriptive name for THIS plan. Must be distinct from the request title and from any sibling plans on the same request. Keep it under 120 characters."
+  ),
   scope: z2.enum(["feat", "fix", "chore", "docs", "test", "refactor"]).describe("The primary intent of the change."),
   goal: z2.string().min(1).describe("One or two sentences stating the outcome."),
   assumptions: z2.array(z2.string()).describe("Anything decided during planning, including unanswered defaults."),
@@ -188,6 +191,8 @@ var planInputSchema = {
 var planSchema = z2.object(planInputSchema);
 function renderPlan(plan) {
   const lines = [];
+  lines.push(`# ${plan.title}`);
+  lines.push("");
   lines.push(`**Scope** \u2014 \`${plan.scope}\``);
   lines.push("");
   lines.push(`**Goal** \u2014 ${plan.goal}`);
@@ -235,7 +240,7 @@ function createPlanTooling() {
   let renderedPlan = null;
   const submitPlan = tool2(
     SUBMIT_PLAN,
-    "Submit the finished plan. Call this \u2014 and only this \u2014 when the plan is complete and ready to post. The runner renders your structured fields into the canonical plan markdown and posts it as your comment. acceptanceCriteria is required and must contain at least 2 observable, verifiable conditions (behaviors, tests, or states you could check) that together define 'done'. After calling this, end your turn.",
+    "Submit the finished plan. Call this \u2014 and only this \u2014 when the plan is complete and ready to post. The runner renders your structured fields into the canonical plan markdown and posts it as your comment. acceptanceCriteria is required and must contain at least 2 observable, verifiable conditions (behaviors, tests, or states you could check) that together define 'done'. After calling this, end your turn. The `title` field names this specific plan \u2014 make it concise and distinct from the request title.",
     planInputSchema,
     async (args) => {
       renderedPlan = renderPlan(planSchema.parse(args));
@@ -455,6 +460,25 @@ function buildDocumentPrompt(ctx) {
   lines.push("", "When done, reply with a one- or two-line summary of the wiki changes you made.");
   return lines.join("\n");
 }
+function buildRepairPrompt(ctx, hookLog) {
+  const lines = [
+    `You are "${ctx.agentName}", fixing a failed pre-commit check in the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
+    `The changes from the previous step are still uncommitted in the working tree. When the runner tried to commit them, the repository's pre-commit hook \u2014 which runs the project's own checks (lint / typecheck / unit tests) \u2014 failed. Make the working tree pass those checks: fix the failing code or tests at their root. Do NOT delete or skip tests, weaken assertions, or disable the checks to silence the failure. Preserve the intent of the original change; repair only what's broken. Do NOT commit or push \u2014 the runner re-commits once the checks pass.`,
+    "",
+    "These coding guidelines apply to all code produced in this run:",
+    "",
+    loadRule("coding-guideline"),
+    "",
+    "# Pre-commit hook output",
+    "",
+    "```",
+    hookLog,
+    "```",
+    "",
+    "When done, reply with a one-line summary of what you fixed."
+  ];
+  return lines.join("\n");
+}
 function buildInitPrompt(ctx) {
   return [
     `You are "${ctx.agentName}" initializing FlumeCode for the repository ${ctx.repo.fullName}, checked out in your current working directory.`,
@@ -508,6 +532,48 @@ async function installDependencies(dir) {
 async function makeWorkspace() {
   return mkdtemp(join3(tmpdir(), WORKSPACE_PREFIX));
 }
+var MAX_WORKSPACES = 8;
+var workspaceRegistry = /* @__PURE__ */ new Map();
+async function acquireWorkspace(key) {
+  const existing = workspaceRegistry.get(key);
+  if (existing !== void 0 && existsSync2(existing)) {
+    workspaceRegistry.delete(key);
+    workspaceRegistry.set(key, existing);
+    return { dir: existing, reused: true };
+  }
+  const dir = await makeWorkspace();
+  workspaceRegistry.set(key, dir);
+  if (workspaceRegistry.size > MAX_WORKSPACES) {
+    const oldest = workspaceRegistry.keys().next().value;
+    const oldDir = workspaceRegistry.get(oldest);
+    workspaceRegistry.delete(oldest);
+    rm(oldDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  return { dir, reused: false };
+}
+async function discardWorkspace(key) {
+  const dir = workspaceRegistry.get(key);
+  workspaceRegistry.delete(key);
+  if (dir !== void 0) {
+    await cleanup(dir).catch(() => {
+    });
+  }
+}
+async function prepareAtSha(ctx, dir, reused) {
+  if (!reused) {
+    await cloneAtSha(ctx, dir);
+    return;
+  }
+  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
+}
+async function prepareResumingBranch(ctx, dir, reused) {
+  if (!reused) {
+    return cloneResumingBranch(ctx, dir);
+  }
+  await git(["-C", dir, "remote", "set-url", "origin", cloneUrl(ctx)]);
+  return { resumed: true };
+}
 async function sweepWorkspaces() {
   const base = tmpdir();
   let entries;
@@ -547,20 +613,36 @@ async function hasChanges(dir) {
   const { stdout: stdout2 } = await git(["-C", dir, "status", "--porcelain"]);
   return stdout2.trim().length > 0;
 }
+var PreCommitError = class extends Error {
+  constructor(log) {
+    super("pre-commit checks failed");
+    this.log = log;
+    this.name = "PreCommitError";
+  }
+};
+function commitFailureLog(err) {
+  const e = err;
+  const parts = [e.stdout, e.stderr].map((s) => typeof s === "string" ? s.trim() : "").filter((s) => s.length > 0);
+  return parts.length > 0 ? parts.join("\n") : e.message ?? String(err);
+}
 async function commitChanges(ctx, dir) {
   if (!await hasChanges(dir)) return false;
-  await git([
-    "-C",
-    dir,
-    "-c",
-    "user.email=runner@flumecode.local",
-    "-c",
-    "user.name=FlumeCode Runner",
-    "commit",
-    "--quiet",
-    "-m",
-    `FlumeCode: ${jobTitle(ctx)}`
-  ]);
+  try {
+    await git([
+      "-C",
+      dir,
+      "-c",
+      "user.email=runner@flumecode.local",
+      "-c",
+      "user.name=FlumeCode Runner",
+      "commit",
+      "--quiet",
+      "-m",
+      `FlumeCode: ${jobTitle(ctx)}`
+    ]);
+  } catch (err) {
+    throw new PreCommitError(commitFailureLog(err));
+  }
   return true;
 }
 async function pushBranch(ctx, dir) {
@@ -638,17 +720,37 @@ async function cleanup(dir) {
 var IDLE_MS = 5e3;
 var ORCHESTRATOR_MODEL = "sonnet";
 var ORCHESTRATOR_MAX_TURNS = 80;
+var MAX_COMMIT_REPAIRS = 2;
 var INIT_MAX_TURNS = 200;
 var DOCUMENT_MAX_TURNS = 120;
 var HEARTBEAT_MS = 5 * 6e4;
 async function pushAndOpenPr(ctx, dir, opts = { rebase: true }) {
-  const committed = await commitChanges(ctx, dir);
+  const committed = await commitWithRepair(ctx, dir);
   if (!committed) return { kind: "none" };
   if (opts.rebase) await rebaseOntoMergeBranch(ctx, dir);
   await pushBranch(ctx, dir);
   const pr = await openPullRequest(ctx);
   return pr ? { kind: "pr", pr } : { kind: "pushed" };
 }
+async function commitWithRepair(ctx, dir) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await commitChanges(ctx, dir);
+    } catch (err) {
+      if (!(err instanceof PreCommitError) || attempt > MAX_COMMIT_REPAIRS) throw err;
+      console.warn(
+        `  pre-commit checks failed (repair ${attempt}/${MAX_COMMIT_REPAIRS}) \u2014 asking the agent to fix\u2026`
+      );
+      await runClaudeCode({
+        cwd: dir,
+        prompt: buildRepairPrompt(ctx, err.log),
+        permissionMode: ctx.permissionMode,
+        model: ORCHESTRATOR_MODEL,
+        maxTurns: ORCHESTRATOR_MAX_TURNS
+      });
+    }
+  }
+}
 function outcomeBanner(outcome, opts) {
   const wikiNote = opts.documented ? " (with wiki updates)" : "";
   switch (outcome.kind) {
@@ -670,20 +772,35 @@ function outcomeBanner(outcome, opts) {
   }
 }
 async function processJob(ctx) {
-  const dir = await makeWorkspace();
+  const { dir, reused } = await acquireWorkspace(ctx.workspaceKey);
+  let prepared = false;
   try {
-    if (ctx.kind === "init") return await processInitJob(ctx, dir);
-    if (ctx.kind === "implement") return await processImplementJob(ctx, dir);
-    if (ctx.kind === "revise") return await processReviseJob(ctx, dir);
+    if (ctx.kind === "init") {
+      await prepareAtSha(ctx, dir, reused);
+      prepared = true;
+      return await processInitJob(ctx, dir);
+    }
+    if (ctx.kind === "implement") {
+      const { resumed } = await prepareResumingBranch(ctx, dir, reused);
+      prepared = true;
+      return await processImplementJob(ctx, dir, resumed);
+    }
+    if (ctx.kind === "revise") {
+      const { resumed } = await prepareResumingBranch(ctx, dir, reused);
+      prepared = true;
+      return await processReviseJob(ctx, dir, resumed);
+    }
+    await prepareAtSha(ctx, dir, reused);
+    prepared = true;
     return await processChatJob(ctx, dir);
-  } finally {
-    await cleanup(dir);
+  } catch (err) {
+    if (!prepared) await discardWorkspace(ctx.workspaceKey);
+    throw err;
   }
 }
 async function processInitJob(ctx, dir) {
   console.log(`
 \u25B6 Init ${ctx.jobId} \u2014 ${ctx.repo.fullName} on ${ctx.repo.checkoutBranch}`);
-  await cloneAtSha(ctx, dir);
   const summary = (await runClaudeCode({
     cwd: dir,
     prompt: buildInitPrompt(ctx),
@@ -701,7 +818,6 @@ async function processInitJob(ctx, dir) {
 async function processChatJob(ctx, dir) {
   console.log(`
 \u25B6 Job ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
-  await cloneAtSha(ctx, dir);
   const orchestrating = ctx.permissionMode !== "plan";
   const installResult = orchestrating ? await installDependencies(dir) : null;
   const result = await runClaudeCode({
@@ -743,10 +859,9 @@ async function processChatJob(ctx, dir) {
   reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented });
   return { text: reply, widgets: [] };
 }
-async function processImplementJob(ctx, dir) {
+async function processImplementJob(ctx, dir, resumed) {
   console.log(`
 \u25B6 Implement ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
-  const { resumed } = await cloneResumingBranch(ctx, dir);
   const installResult = await installDependencies(dir);
   const result = await runClaudeCode({
     cwd: dir,
@@ -780,10 +895,9 @@ async function processImplementJob(ctx, dir) {
   reply += outcomeBanner(outcome, { branch: ctx.repo.checkoutBranch, documented });
   return { text: reply, widgets: [], ...outcome.kind === "pr" ? { pr: outcome.pr } : {} };
 }
-async function processReviseJob(ctx, dir) {
+async function processReviseJob(ctx, dir, resumed) {
   console.log(`
 \u25B6 Revise ${ctx.jobId} \u2014 ${ctx.repo.fullName}: "${jobTitle(ctx)}"`);
-  const { resumed } = await cloneResumingBranch(ctx, dir);
   const installResult = await installDependencies(dir);
   const result = await runClaudeCode({
     cwd: dir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flumecode/runner",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "FlumeCode local runner — claims jobs and drives your local Claude Code against a real checkout.",
   "bin": {

package/skills-plugin/skills/request-to-plan/SKILL.md

@@ -57,6 +57,8 @@ it as your comment — do **not** write the plan as your reply text.
 
 Field-by-field guidance:
 
+- **`title`** — a concise, descriptive name for this specific plan. Must be distinct from the
+  request title and from any sibling plans on the same request. Keep it under 120 characters.
 - **`scope`** — exactly one of `feat`, `fix`, `chore`, `docs`, `test`,
   `refactor`. Pick the one that best matches the primary intent of the request.
 - **`goal`** — one or two sentences stating the outcome, phrased so it directly
@@ -85,9 +87,10 @@ plan without re-deriving it.
 A single request can yield **several** plans — one thread can be accepted into
 many. If the work naturally splits into independent pieces, or the user asks for
 more than one plan, call `submit_plan` once for each finished plan so each can
-be accepted into its own GitHub issue. After a plan is accepted the user may
-keep commenting to refine it; treat a later turn as a fresh **Plan** phase and
-call `submit_plan` again with the revised fields.
+be accepted into its own GitHub issue. Give each plan its own distinct `title`
+so sibling plans don't collide. After a plan is accepted the user may keep
+commenting to refine it; treat a later turn as a fresh **Plan** phase and call
+`submit_plan` again with the revised fields.
 
 ## Always