@callumvass/forgeflow-dev 0.1.0 → 0.3.1

package/src/pipelines/implement-all.ts

@@ -1,181 +0,0 @@
-import { type AnyCtx, emptyStage, type StageResult, sumUsage } from "@callumvass/forgeflow-shared";
-import { exec } from "../utils/exec.js";
-import { setForgeflowStatus, updateProgressWidget } from "../utils/ui.js";
-import { runImplement } from "./implement.js";
-
-interface IssueInfo {
-  number: number;
-  title: string;
-  body: string;
-}
-
-/**
- * Get issue numbers whose dependencies (referenced as #N in ## Dependencies section) are satisfied.
- */
-function getReadyIssues(issues: IssueInfo[], completed: Set<number>): number[] {
-  return issues
-    .filter((issue) => {
-      if (completed.has(issue.number)) return false;
-      const parts = issue.body.split("## Dependencies");
-      if (parts.length < 2) return true;
-      const depSection = parts[1]?.split("\n## ")[0] ?? "";
-      const deps = [...depSection.matchAll(/#(\d+)/g)].map((m) => parseInt(m[1] ?? "0", 10));
-      return deps.every((d) => completed.has(d));
-    })
-    .map((i) => i.number);
-}
-
-export async function runImplementAll(
-  cwd: string,
-  signal: AbortSignal,
-  onUpdate: AnyCtx,
-  ctx: AnyCtx,
-  flags: { skipPlan: boolean; skipReview: boolean },
-) {
-  const allStages: StageResult[] = [];
-  const issueProgress = new Map<number, { title: string; status: "pending" | "running" | "done" | "failed" }>();
-
-  // Seed completed set with already-closed issues
-  const closedJson = await exec(
-    `gh issue list --state closed --label "auto-generated" --json number --jq '.[].number'`,
-    cwd,
-  );
-  const completed = new Set<number>(closedJson ? closedJson.split("\n").filter(Boolean).map(Number) : []);
-
-  let iteration = 0;
-  const maxIterations = 50;
-
-  while (iteration++ < maxIterations) {
-    if (signal.aborted) break;
-
-    // Return to main and pull
-    await exec("git checkout main && git pull --rebase", cwd);
-
-    // Fetch open issues
-    const issuesJson = await exec(
-      `gh issue list --state open --label "auto-generated" --json number,title,body --jq 'sort_by(.number)'`,
-      cwd,
-    );
-    let issues: IssueInfo[];
-    try {
-      issues = JSON.parse(issuesJson || "[]");
-    } catch {
-      issues = [];
-    }
-
-    if (issues.length === 0) {
-      return {
-        content: [{ type: "text" as const, text: "All issues implemented." }],
-        details: { pipeline: "implement-all", stages: allStages },
-      };
-    }
-
-    // Track all known issues in progress widget
-    for (const issue of issues) {
-      if (!issueProgress.has(issue.number)) {
-        issueProgress.set(issue.number, { title: issue.title, status: "pending" });
-      }
-    }
-
-    // Find ready issues (deps satisfied)
-    const ready = getReadyIssues(issues, completed);
-    if (ready.length === 0) {
-      return {
-        content: [
-          { type: "text" as const, text: `${issues.length} issues remain but all have unresolved dependencies.` },
-        ],
-        details: { pipeline: "implement-all", stages: allStages },
-        isError: true,
-      };
-    }
-
-    // biome-ignore lint/style/noNonNullAssertion: ready is non-empty (checked above)
-    const issueNum = ready[0]!;
-    const issueTitle = issues.find((i) => i.number === issueNum)?.title ?? `#${issueNum}`;
-
-    // Update status + widget
-    issueProgress.set(issueNum, { title: issueTitle, status: "running" });
-    setForgeflowStatus(
-      ctx,
-      `implement-all · ${completed.size}/${completed.size + issues.length} · #${issueNum} ${issueTitle}`,
-    );
-    updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
-
-    // Run implement for this issue
-    allStages.push(emptyStage(`implement-${issueNum}`));
-    const implResult = await runImplement(cwd, String(issueNum), signal, onUpdate, ctx, {
-      ...flags,
-      autonomous: true,
-    });
-
-    // Accumulate usage from detailed stages into the container stage
-    const implStage = allStages.find((s) => s.name === `implement-${issueNum}`);
-    if (implStage) {
-      implStage.status = implResult.isError ? "failed" : "done";
-      implStage.output = implResult.content[0]?.type === "text" ? implResult.content[0].text : "";
-      const detailedStages = (implResult as AnyCtx).details?.stages as StageResult[] | undefined;
-      if (detailedStages) implStage.usage = sumUsage(detailedStages);
-    }
-
-    if (implResult.isError) {
-      issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
-      updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Failed on issue #${issueNum}: ${implResult.content[0]?.type === "text" ? implResult.content[0].text : "unknown error"}`,
-          },
-        ],
-        details: { pipeline: "implement-all", stages: allStages },
-        isError: true,
-      };
-    }
-
-    // Check for PR and merge
-    const branch = `feat/issue-${issueNum}`;
-    await exec("git checkout main && git pull --rebase", cwd);
-    const prNum = await exec(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
-
-    if (prNum && prNum !== "null") {
-      const mergeResult = await exec(`gh pr merge ${prNum} --squash --delete-branch`, cwd);
-      if (mergeResult.includes("Merged") || mergeResult === "") {
-        completed.add(issueNum);
-      } else {
-        const prState = await exec(`gh pr view ${prNum} --json state --jq '.state'`, cwd);
-        if (prState === "MERGED") {
-          completed.add(issueNum);
-        } else {
-          issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
-          updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
-          return {
-            content: [{ type: "text" as const, text: `Failed to merge PR #${prNum} for issue #${issueNum}.` }],
-            details: { pipeline: "implement-all", stages: allStages },
-            isError: true,
-          };
-        }
-      }
-    } else {
-      issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
-      updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
-      return {
-        content: [{ type: "text" as const, text: `No PR found for issue #${issueNum} after implementation.` }],
-        details: { pipeline: "implement-all", stages: allStages },
-        isError: true,
-      };
-    }
-
-    // Mark done and update widget
-    issueProgress.set(issueNum, { title: issueTitle, status: "done" });
-    setForgeflowStatus(
-      ctx,
-      `implement-all · ${completed.size}/${completed.size + issues.length - 1} · $${sumUsage(allStages).cost.toFixed(2)}`,
-    );
-    updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
-  }
-
-  return {
-    content: [{ type: "text" as const, text: `Reached max iterations (${maxIterations}).` }],
-    details: { pipeline: "implement-all", stages: allStages },
-  };
-}

package/src/pipelines/implement.ts

@@ -1,305 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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(""));
-  });
-}