@callumvass/forgeflow-dev 0.1.0

package/src/pipelines/implement.ts

@@ -0,0 +1,305 @@
+import {
+  type AnyCtx,
+  cleanSignal,
+  emptyStage,
+  readSignal,
+  runAgent,
+  type StageResult,
+  signalExists,
+  TOOLS_ALL,
+  TOOLS_READONLY,
+} from "@callumvass/forgeflow-shared";
+import { AGENTS_DIR } from "../resolve.js";
+import { exec } from "../utils/exec.js";
+import { ensureBranch, resolveIssue } from "../utils/git.js";
+import { setForgeflowStatus } from "../utils/ui.js";
+import { runReviewInline } from "./review.js";
+
+/**
+ * Run review and fix any findings via implementor.
+ */
+async function reviewAndFix(
+  cwd: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+  stages: StageResult[],
+  pipeline = "implement",
+): Promise<void> {
+  const reviewResult = await runReviewInline(cwd, signal, onUpdate, ctx, stages);
+  if (reviewResult.isError) {
+    const findings = reviewResult.content[0]?.type === "text" ? reviewResult.content[0].text : "";
+    stages.push(emptyStage("fix-findings"));
+    await runAgent(
+      "implementor",
+      `Fix the following code review findings:\n\n${findings}\n\nRULES:\n- Fix only the cited issues. Do not refactor or improve unrelated code.\n- Run the check command after fixes.\n- Commit and push the fixes.`,
+      { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate, tools: TOOLS_ALL, stageName: "fix-findings" },
+    );
+    cleanSignal(cwd, "findings");
+  }
+}
+
+/**
+ * Run refactorer then review+fix. Shared by fresh implementation and resume-from-branch paths.
+ */
+async function refactorAndReview(
+  cwd: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+  stages: StageResult[],
+  skipReview: boolean,
+  pipeline = "implement",
+): Promise<void> {
+  if (!stages.some((s) => s.name === "refactorer")) stages.push(emptyStage("refactorer"));
+  await runAgent(
+    "refactorer",
+    "Review code added in this branch (git diff main...HEAD). Refactor if clear wins exist. Run checks after changes. Commit and push if changed.",
+    { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate, tools: TOOLS_ALL },
+  );
+
+  if (!skipReview) {
+    await reviewAndFix(cwd, signal, onUpdate, ctx, stages, pipeline);
+  }
+}
+
+/**
+ * Parse unresolved questions from the plan and prompt the user for answers.
+ * Returns the plan with answers injected inline.
+ */
+async function resolveQuestions(plan: string, ctx: AnyCtx): Promise<string> {
+  const sectionMatch = plan.match(/### Unresolved Questions\n([\s\S]*?)(?=\n###|$)/);
+  if (!sectionMatch) return plan;
+
+  const section = sectionMatch[1] ?? "";
+  const questions: string[] = [];
+  for (const m of section.matchAll(/^- (.+)$/gm)) {
+    if (m[1]) questions.push(m[1]);
+  }
+
+  if (questions.length === 0) return plan;
+
+  let updatedSection = section;
+  for (const q of questions) {
+    const answer = await ctx.ui.input(`${q}`, "Skip to use defaults");
+    if (answer != null && answer.trim() !== "") {
+      updatedSection = updatedSection.replace(`- ${q}`, `- ${q}\n  **Answer:** ${answer.trim()}`);
+    }
+  }
+
+  return plan.replace(`### Unresolved Questions\n${section}`, `### Unresolved Questions\n${updatedSection}`);
+}
+
+export async function runImplement(
+  cwd: string,
+  issueArg: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+  flags: { skipPlan: boolean; skipReview: boolean; autonomous?: boolean; customPrompt?: string } = {
+    skipPlan: false,
+    skipReview: false,
+  },
+) {
+  const interactive = ctx.hasUI && !flags.autonomous;
+  const resolved = await resolveIssue(cwd, issueArg || undefined);
+  if (typeof resolved === "string") {
+    return { content: [{ type: "text" as const, text: resolved }], details: { pipeline: "implement", stages: [] } };
+  }
+
+  const isGitHub = resolved.source === "github" && resolved.number > 0;
+  const issueLabel = isGitHub ? `#${resolved.number}: ${resolved.title}` : `${resolved.key}: ${resolved.title}`;
+
+  // Status line for standalone /implement (implement-all manages its own)
+  if (!flags.autonomous && (resolved.number || resolved.key)) {
+    const tag = isGitHub ? `#${resolved.number}` : resolved.key;
+    setForgeflowStatus(ctx, `${tag} ${resolved.title} · ${resolved.branch}`);
+  }
+
+  const issueContext = isGitHub
+    ? `Issue #${resolved.number}: ${resolved.title}\n\n${resolved.body}`
+    : `Jira ${resolved.key}: ${resolved.title}\n\n${resolved.body}`;
+
+  const customPromptSection = flags.customPrompt ? `\n\nADDITIONAL INSTRUCTIONS FROM USER:\n${flags.customPrompt}` : "";
+
+  // --- Resumability: skip to review if work already exists ---
+  if (resolved.existingPR) {
+    const stages: StageResult[] = [];
+    if (!flags.skipReview) {
+      await reviewAndFix(cwd, signal, onUpdate, ctx, stages);
+    }
+    return {
+      content: [{ type: "text" as const, text: `Resumed ${issueLabel} — PR #${resolved.existingPR} already exists.` }],
+      details: { pipeline: "implement", stages },
+    };
+  }
+
+  if (resolved.branch) {
+    const branchExists = await exec(
+      `git rev-parse --verify ${resolved.branch} 2>/dev/null && echo yes || echo no`,
+      cwd,
+    );
+    if (branchExists === "yes") {
+      await ensureBranch(cwd, resolved.branch);
+      const ahead = await exec(`git rev-list main..${resolved.branch} --count`, cwd);
+      if (parseInt(ahead, 10) > 0) {
+        await exec(`git push -u origin ${resolved.branch}`, cwd);
+        const prBody = isGitHub ? `Closes #${resolved.number}` : `Jira: ${resolved.key}`;
+        await exec(`gh pr create --title "${resolved.title}" --body "${prBody}" --head ${resolved.branch}`, cwd);
+
+        const stages: StageResult[] = [];
+        await refactorAndReview(cwd, signal, onUpdate, ctx, stages, flags.skipReview);
+        return {
+          content: [{ type: "text" as const, text: `Resumed ${issueLabel} — pushed existing commits and created PR.` }],
+          details: { pipeline: "implement", stages },
+        };
+      }
+    }
+  }
+
+  // --- Fresh implementation ---
+  const stageList: StageResult[] = [];
+  if (!flags.skipPlan) stageList.push(emptyStage("planner"));
+  stageList.push(emptyStage("implementor"));
+  stageList.push(emptyStage("refactorer"));
+  const stages = stageList;
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "implement", onUpdate };
+
+  let plan = "";
+
+  if (!flags.skipPlan) {
+    const planResult = await runAgent(
+      "planner",
+      `Plan the implementation for this issue by producing a sequenced list of test cases.\n\n${issueContext}${customPromptSection}`,
+      { ...opts, tools: TOOLS_READONLY },
+    );
+
+    if (planResult.status === "failed") {
+      return {
+        content: [{ type: "text" as const, text: `Planner failed: ${planResult.output}` }],
+        details: { pipeline: "implement", stages },
+        isError: true,
+      };
+    }
+    plan = planResult.output;
+
+    // Interactive mode: let user review/edit the plan before proceeding
+    if (interactive && plan) {
+      const edited = await ctx.ui.editor(`Review implementation plan for ${issueLabel}`, plan);
+      if (edited != null && edited !== plan) {
+        plan = edited;
+      }
+
+      // Surface unresolved questions one-by-one for user answers
+      plan = await resolveQuestions(plan, ctx);
+
+      const action = await ctx.ui.select("Plan ready. What next?", ["Approve and implement", "Cancel"]);
+      if (action === "Cancel" || action == null) {
+        return {
+          content: [{ type: "text" as const, text: "Implementation cancelled." }],
+          details: { pipeline: "implement", stages },
+        };
+      }
+    }
+  }
+
+  // Create/checkout feature branch if on main
+  if (resolved.branch) {
+    const currentBranch = await exec("git branch --show-current", cwd);
+    if (currentBranch === "main" || currentBranch === "master") {
+      const dirty = await exec("git status --porcelain", cwd);
+      if (dirty) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Cannot switch to ${resolved.branch} — working tree is dirty. Please commit or stash your changes first.`,
+            },
+          ],
+          details: { pipeline: "implement", stages: [] },
+          isError: true,
+        };
+      }
+      await ensureBranch(cwd, resolved.branch);
+      const afterBranch = await exec("git branch --show-current", cwd);
+      if (afterBranch !== resolved.branch) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to switch to ${resolved.branch} (still on ${afterBranch}). Check git state and retry.`,
+            },
+          ],
+          details: { pipeline: "implement", stages: [] },
+          isError: true,
+        };
+      }
+    }
+  }
+
+  // Clean up stale blockers
+  cleanSignal(cwd, "blocked");
+
+  // Implementor
+  const planSection = plan ? `\n\nIMPLEMENTATION PLAN:\n${plan}` : "";
+  const branchNote = resolved.branch
+    ? `\n- You should be on branch: ${resolved.branch} — do NOT create or switch branches.`
+    : "\n- Do NOT create or switch branches.";
+  const prNote = resolved.existingPR ? `\n- PR #${resolved.existingPR} already exists for this branch.` : "";
+  const closeNote = isGitHub
+    ? `\n- The PR body MUST include 'Closes #${resolved.number}' so the issue auto-closes on merge.`
+    : `\n- The PR body should reference Jira issue ${resolved.key}.`;
+  const unresolvedNote = flags.autonomous
+    ? `\n- If the plan has unresolved questions, resolve them yourself using sensible defaults. Do NOT stop and wait.`
+    : "";
+
+  await runAgent(
+    "implementor",
+    `Implement the following issue using strict TDD (red-green-refactor).\n\n${issueContext}${planSection}${customPromptSection}\n\nWORKFLOW:\n1. Read the codebase.\n2. TDD${plan ? " following the plan" : ""}.\n3. Refactor after all tests pass.\n4. Run check command, fix failures.\n5. Commit, push, and create a PR.\n\nCONSTRAINTS:${branchNote}${prNote}${closeNote}${unresolvedNote}\n- If blocked, write BLOCKED.md with the reason and stop.`,
+    { ...opts, tools: TOOLS_ALL },
+  );
+
+  // Check for blocker
+  if (signalExists(cwd, "blocked")) {
+    const reason = readSignal(cwd, "blocked") ?? "";
+    return {
+      content: [{ type: "text" as const, text: `Implementor blocked:\n${reason}` }],
+      details: { pipeline: "implement", stages },
+      isError: true,
+    };
+  }
+
+  // Refactor + review
+  await refactorAndReview(cwd, signal, onUpdate, ctx, stages, flags.skipReview);
+
+  // Ensure PR exists — agent may have skipped or failed `gh pr create`
+  let prNumber = "";
+  if (resolved.branch) {
+    await exec(`git push -u origin ${resolved.branch}`, cwd);
+    prNumber = await exec(`gh pr list --head "${resolved.branch}" --json number --jq '.[0].number'`, cwd);
+    if (!prNumber || prNumber === "null") {
+      const prBody = isGitHub ? `Closes #${resolved.number}` : `Jira: ${resolved.key}`;
+      await exec(`gh pr create --title "${resolved.title}" --body "${prBody}" --head ${resolved.branch}`, cwd);
+      prNumber = await exec(`gh pr list --head "${resolved.branch}" --json number --jq '.[0].number'`, cwd);
+    }
+  }
+
+  // Squash-merge, delete branch, update local main (skip when called from implement-all)
+  if (!flags.autonomous && prNumber && prNumber !== "null") {
+    const mergeStage = emptyStage("merge");
+    stages.push(mergeStage);
+    await exec(`gh pr merge ${prNumber} --squash --delete-branch`, cwd);
+    await exec("git checkout main && git pull", cwd);
+    mergeStage.status = "done";
+    mergeStage.output = `Merged PR #${prNumber}`;
+    onUpdate?.({
+      content: [{ type: "text", text: "Pipeline complete" }],
+      details: { pipeline: "implement", stages },
+    });
+  }
+
+  return {
+    content: [{ type: "text" as const, text: `Implementation of ${issueLabel} complete.` }],
+    details: { pipeline: "implement", stages },
+  };
+}

package/src/pipelines/review.ts

@@ -0,0 +1,183 @@
+import {
+  type AnyCtx,
+  cleanSignal,
+  emptyStage,
+  readSignal,
+  runAgent,
+  type StageResult,
+  signalExists,
+  TOOLS_NO_EDIT,
+  TOOLS_READONLY,
+} from "@callumvass/forgeflow-shared";
+import { AGENTS_DIR } from "../resolve.js";
+import { exec } from "../utils/exec.js";
+
+/**
+ * Shared review logic — used by both standalone /review and chained from /implement.
+ * Appends code-reviewer + review-judge stages to the provided stages array.
+ */
+export async function runReviewInline(
+  cwd: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+  stages: StageResult[],
+  diffCmd = "git diff main...HEAD",
+  pipeline = "review",
+  options: { prNumber?: string; interactive?: boolean; customPrompt?: string } = {},
+): Promise<{ content: { type: "text"; text: string }[]; isError?: boolean }> {
+  const diff = await exec(diffCmd, cwd);
+
+  if (!diff) {
+    return { content: [{ type: "text", text: "No changes to review." }] };
+  }
+
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate };
+  const extraInstructions = options.customPrompt
+    ? `\n\nADDITIONAL INSTRUCTIONS FROM USER:\n${options.customPrompt}`
+    : "";
+
+  // Clean up stale findings
+  cleanSignal(cwd, "findings");
+
+  // Code reviewer
+  stages.push(emptyStage("code-reviewer"));
+  await runAgent("code-reviewer", `Review the following diff:\n\n${diff}${extraInstructions}`, {
+    ...opts,
+    tools: TOOLS_NO_EDIT,
+  });
+
+  if (!signalExists(cwd, "findings")) {
+    return { content: [{ type: "text", text: "Review passed — no actionable findings." }] };
+  }
+
+  // Review judge
+  stages.push(emptyStage("review-judge"));
+  const findings = readSignal(cwd, "findings") ?? "";
+  await runAgent(
+    "review-judge",
+    `Validate the following code review findings against the actual code:\n\n${findings}`,
+    { ...opts, tools: TOOLS_NO_EDIT },
+  );
+
+  if (!signalExists(cwd, "findings")) {
+    return { content: [{ type: "text", text: "Review passed — judge filtered all findings." }] };
+  }
+
+  const validatedFindings = readSignal(cwd, "findings") ?? "";
+
+  // Interactive mode with PR: show findings and proposed gh commands for approval
+  if (options.interactive && options.prNumber) {
+    const repo = await exec("gh repo view --json nameWithOwner --jq .nameWithOwner", cwd);
+    const prNum = options.prNumber;
+
+    const proposalPrompt = `You have validated code review findings for PR #${prNum} in ${repo}.
+
+FINDINGS:
+${validatedFindings}
+
+Generate ready-to-run \`gh api\` commands to post each finding as a PR review comment. One command per finding.
+
+Format each as:
+
+**Finding N** — path/to/file.ts:LINE
+
+\`\`\`bash
+gh api repos/${repo}/pulls/${prNum}/comments \\
+  --method POST \\
+  --field body="<comment>" \\
+  --field commit_id="$(gh pr view ${prNum} --repo ${repo} --json headRefOid -q .headRefOid)" \\
+  --field path="path/to/file.ts" \\
+  --field line=LINE \\
+  --field side="RIGHT"
+\`\`\`
+
+Comment tone rules:
+- Write like a teammate, not an auditor. Casual, brief, direct.
+- 1-2 short sentences max. Lead with the suggestion, not the problem.
+- Use "might be worth..." / "could we..." / "what about..." / "small thing:"
+- No em dashes, no "Consider...", no "Note that...", no hedging filler.
+- Use GitHub \`\`\`suggestion\`\`\` blocks when proposing code changes.
+- Only generate commands for findings with a specific file + line.
+
+After the comments, add the review decision command:
+
+\`\`\`bash
+gh pr review ${prNum} --request-changes --body "Left a few comments" --repo ${repo}
+\`\`\`
+
+Output ONLY the commands, no other text.`;
+
+    stages.push(emptyStage("propose-comments"));
+    await runAgent("review-judge", proposalPrompt, {
+      agentsDir: AGENTS_DIR,
+      cwd,
+      signal,
+      stages,
+      pipeline,
+      onUpdate,
+      tools: TOOLS_READONLY,
+    });
+
+    const commentStage = stages.find((s) => s.name === "propose-comments");
+    const proposedCommands = commentStage?.output || "";
+
+    if (proposedCommands && ctx.hasUI) {
+      const reviewed = await ctx.ui.editor(
+        `Review PR comments for PR #${prNum} (edit or close to skip)`,
+        `${validatedFindings}\n\n---\n\nProposed commands (run these to post):\n\n${proposedCommands}`,
+      );
+
+      if (reviewed != null) {
+        const action = await ctx.ui.select("Post these review comments?", ["Post comments", "Skip"]);
+        if (action === "Post comments") {
+          const commands = reviewed.match(/```bash\n([\s\S]*?)```/g) || [];
+          for (const block of commands) {
+            const cmd = block
+              .replace(/```bash\n/, "")
+              .replace(/```$/, "")
+              .trim();
+            if (cmd.startsWith("gh ")) {
+              await exec(cmd, cwd);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { content: [{ type: "text", text: validatedFindings }], isError: true };
+}
+
+export async function runReview(
+  cwd: string,
+  target: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+  customPrompt?: string,
+) {
+  const stages: StageResult[] = [];
+
+  let diffCmd = "git diff main...HEAD";
+  let prNumber: string | undefined;
+
+  if (target.match(/^\d+$/)) {
+    diffCmd = `gh pr diff ${target}`;
+    prNumber = target;
+  } else if (target.startsWith("--branch")) {
+    const branch = target.replace("--branch", "").trim() || "HEAD";
+    diffCmd = `git diff main...${branch}`;
+  } else {
+    // Try to detect PR from current branch
+    const pr = await exec("gh pr view --json number --jq .number 2>/dev/null", cwd);
+    if (pr && pr !== "") prNumber = pr;
+  }
+
+  const result = await runReviewInline(cwd, signal, onUpdate, ctx, stages, diffCmd, "review", {
+    prNumber,
+    interactive: ctx.hasUI,
+    customPrompt,
+  });
+  return { ...result, details: { pipeline: "review", stages } };
+}

package/src/resolve.ts

@@ -0,0 +1,6 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// After bundling: extensions/index.js → up one level → agents/
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const AGENTS_DIR = path.resolve(__dirname, "..", "agents");

package/src/utils/exec.ts

@@ -0,0 +1,13 @@
+import { spawn } from "node:child_process";
+
+export function exec(cmd: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const proc = spawn("bash", ["-c", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    proc.stdout.on("data", (d: Buffer) => {
+      out += d.toString();
+    });
+    proc.on("close", () => resolve(out.trim()));
+    proc.on("error", () => resolve(""));
+  });
+}

package/src/utils/git.ts

@@ -0,0 +1,132 @@
+import { exec } from "./exec.js";
+
+export interface ResolvedIssue {
+  source: "github" | "jira";
+  key: string; // "42" for GH, "CUS-123" for Jira
+  number: number; // GH issue number, 0 for Jira
+  title: string;
+  body: string;
+  branch: string;
+  existingPR?: number;
+}
+
+function slugify(text: string, maxLen = 40): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, maxLen)
+    .replace(/-$/, "");
+}
+
+const JIRA_KEY_RE = /^[A-Z]+-\d+$/;
+const JIRA_BRANCH_RE = /feat\/([A-Z]+-\d+)/;
+
+/**
+ * Checkout a branch, creating it if it doesn't exist.
+ */
+export async function ensureBranch(cwd: string, branch: string): Promise<void> {
+  const currentBranch = await exec("git branch --show-current", cwd);
+  if (currentBranch === branch) return;
+  const exists = await exec(`git rev-parse --verify ${branch} 2>/dev/null && echo yes || echo no`, cwd);
+  if (exists === "yes") {
+    await exec(`git checkout ${branch}`, cwd);
+  } else {
+    await exec(`git checkout -b ${branch}`, cwd);
+  }
+}
+
+/**
+ * Resolve which issue to implement:
+ * 1. Jira key (CUS-123) → fetch from jira-cli
+ * 2. Numeric GitHub issue → fetch from gh
+ * 3. On a feature branch → extract from branch name
+ */
+export async function resolveIssue(cwd: string, issueArg?: string): Promise<ResolvedIssue | string> {
+  // Explicit Jira key
+  if (issueArg && JIRA_KEY_RE.test(issueArg)) {
+    return resolveJiraIssue(cwd, issueArg);
+  }
+
+  // Explicit GitHub issue number
+  if (issueArg && /^\d+$/.test(issueArg)) {
+    return resolveGitHubIssue(cwd, parseInt(issueArg, 10));
+  }
+
+  // Free-text description (not a number or Jira key)
+  if (issueArg) {
+    return { source: "github", key: "", number: 0, title: issueArg, body: issueArg, branch: "" };
+  }
+
+  // Detect from branch name
+  const branch = await exec("git branch --show-current", cwd);
+
+  const jiraMatch = branch.match(JIRA_BRANCH_RE);
+  if (jiraMatch) {
+    // biome-ignore lint/style/noNonNullAssertion: match[1] guaranteed by regex
+    return resolveJiraIssue(cwd, jiraMatch[1]!, branch);
+  }
+
+  const ghMatch = branch.match(/(?:feat\/)?issue-(\d+)/);
+  if (ghMatch) {
+    // biome-ignore lint/style/noNonNullAssertion: match[1] guaranteed by regex
+    return resolveGitHubIssue(cwd, parseInt(ghMatch[1]!, 10));
+  }
+
+  return `On branch "${branch}" — can't detect issue. Use /implement <issue#> or /implement <JIRA-KEY>.`;
+}
+
+async function resolveGitHubIssue(cwd: string, issueNum: number): Promise<ResolvedIssue | string> {
+  const issueJson = await exec(`gh issue view ${issueNum} --json number,title,body`, cwd);
+  if (!issueJson) return `Could not fetch issue #${issueNum}.`;
+
+  let issue: { number: number; title: string; body: string };
+  try {
+    issue = JSON.parse(issueJson);
+  } catch {
+    return `Could not parse issue #${issueNum}.`;
+  }
+
+  const branch = `feat/issue-${issueNum}`;
+  const prJson = await exec(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
+  const existingPR = prJson && prJson !== "null" ? parseInt(prJson, 10) : undefined;
+
+  return { source: "github", key: String(issueNum), ...issue, branch, existingPR };
+}
+
+async function resolveJiraIssue(
+  cwd: string,
+  jiraKey: string,
+  existingBranch?: string,
+): Promise<ResolvedIssue | string> {
+  const raw = await exec(`jira issue view ${jiraKey} --raw`, cwd);
+  if (!raw) return `Could not fetch Jira issue ${jiraKey}.`;
+
+  // biome-ignore lint/suspicious/noExplicitAny: Jira JSON shape varies by instance
+  let data: any;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return `Could not parse Jira issue ${jiraKey}.`;
+  }
+
+  const fields = data.fields ?? {};
+  const title = fields.summary ?? jiraKey;
+
+  // Build body from available Jira fields
+  const bodyParts: string[] = [];
+  if (fields.description) bodyParts.push(fields.description);
+  if (fields.acceptance_criteria) bodyParts.push(`## Acceptance Criteria\n${fields.acceptance_criteria}`);
+  if (fields.status?.name) bodyParts.push(`**Status:** ${fields.status.name}`);
+  if (fields.priority?.name) bodyParts.push(`**Priority:** ${fields.priority.name}`);
+  if (fields.story_points != null) bodyParts.push(`**Story Points:** ${fields.story_points}`);
+  if (fields.sprint?.name) bodyParts.push(`**Sprint:** ${fields.sprint.name}`);
+
+  const body = bodyParts.join("\n\n");
+  const branch = existingBranch ?? `feat/${jiraKey}-${slugify(title)}`;
+
+  const prJson = await exec(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
+  const existingPR = prJson && prJson !== "null" ? parseInt(prJson, 10) : undefined;
+
+  return { source: "jira", key: jiraKey, number: 0, title, body, branch, existingPR };
+}

package/src/utils/ui.ts

@@ -0,0 +1,29 @@
+import type { AnyCtx } from "@callumvass/forgeflow-shared";
+
+export function setForgeflowStatus(ctx: AnyCtx, text: string | undefined): void {
+  if (ctx.hasUI) ctx.ui.setStatus("forgeflow-dev", text);
+}
+
+export function setForgeflowWidget(ctx: AnyCtx, lines: string[] | undefined): void {
+  if (ctx.hasUI) ctx.ui.setWidget("forgeflow-dev", lines);
+}
+
+export function updateProgressWidget(
+  ctx: AnyCtx,
+  progress: Map<number, { title: string; status: string }>,
+  totalCost: number,
+): void {
+  let done = 0;
+  for (const [, info] of progress) {
+    if (info.status === "done") done++;
+  }
+  let header = `implement-all · ${done}/${progress.size}`;
+  if (totalCost > 0) header += ` · $${totalCost.toFixed(2)}`;
+  const lines: string[] = [header];
+  for (const [num, info] of progress) {
+    const icon = info.status === "done" ? "✓" : info.status === "running" ? "⟳" : info.status === "failed" ? "✗" : "○";
+    const title = info.title.length > 50 ? `${info.title.slice(0, 50)}...` : info.title;
+    lines.push(`  ${icon} #${num} ${title}`);
+  }
+  setForgeflowWidget(ctx, lines);
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"],
+  "references": [
+    { "path": "../shared" }
+  ]
+}