@callumvass/forgeflow-pm 0.1.0 → 0.3.2

package/src/index.ts

@@ -1,280 +0,0 @@
-import { type AnyCtx, getFinalOutput, type PipelineDetails, type StageResult } from "@callumvass/forgeflow-shared";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
-import { Type } from "@sinclair/typebox";
-import { runContinue } from "./pipelines/continue.js";
-import { runCreateIssue, runCreateIssues } from "./pipelines/create-issues.js";
-import { runPrdQa } from "./pipelines/prd-qa.js";
-
-// ─── Display helpers ──────────────────────────────────────────────────
-
-type DisplayItem = { type: "text"; text: string } | { type: "toolCall"; name: string; args: Record<string, unknown> };
-
-interface ForgeflowPmInput {
-  pipeline: string;
-  maxIterations?: number;
-  issue?: string;
-}
-
-function getDisplayItems(messages: AnyCtx[]): DisplayItem[] {
-  const items: DisplayItem[] = [];
-  for (const msg of messages) {
-    if (msg.role === "assistant") {
-      for (const part of msg.content) {
-        if (part.type === "text") items.push({ type: "text", text: part.text });
-        else if (part.type === "toolCall") items.push({ type: "toolCall", name: part.name, args: part.arguments });
-      }
-    }
-  }
-  return items;
-}
-
-function formatToolCallShort(
-  name: string,
-  args: Record<string, unknown>,
-  fg: (c: string, t: string) => string,
-): string {
-  switch (name) {
-    case "bash": {
-      const cmd = (args.command as string) || "...";
-      return fg("muted", "$ ") + fg("toolOutput", cmd.length > 60 ? `${cmd.slice(0, 60)}...` : cmd);
-    }
-    case "read":
-      return fg("muted", "read ") + fg("accent", (args.file_path || args.path || "...") as string);
-    case "write":
-      return fg("muted", "write ") + fg("accent", (args.file_path || args.path || "...") as string);
-    case "edit":
-      return fg("muted", "edit ") + fg("accent", (args.file_path || args.path || "...") as string);
-    case "grep":
-      return fg("muted", "grep ") + fg("accent", `/${args.pattern || ""}/`);
-    case "find":
-      return fg("muted", "find ") + fg("accent", (args.pattern || "*") as string);
-    default:
-      return fg("accent", name);
-  }
-}
-
-function formatUsage(usage: { input: number; output: number; cost: number; turns: number }, model?: string): string {
-  const parts: string[] = [];
-  if (usage.turns) parts.push(`${usage.turns}t`);
-  if (usage.input) parts.push(`↑${usage.input < 1000 ? usage.input : `${Math.round(usage.input / 1000)}k`}`);
-  if (usage.output) parts.push(`↓${usage.output < 1000 ? usage.output : `${Math.round(usage.output / 1000)}k`}`);
-  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-  if (model) parts.push(model);
-  return parts.join(" ");
-}
-
-// ─── Tool registration ────────────────────────────────────────────────
-
-const ForgeflowPmParams = Type.Object({
-  pipeline: Type.String({
-    description: 'Which pipeline to run: "continue", "prd-qa", "create-issues", or "create-issue"',
-  }),
-  maxIterations: Type.Optional(Type.Number({ description: "Max iterations for prd-qa (default 10)" })),
-  issue: Type.Optional(Type.String({ description: "Feature idea for create-issue, or description for continue" })),
-});
-
-function registerForgeflowPmTool(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "forgeflow-pm",
-    label: "Forgeflow PM",
-    description: [
-      "Run forgeflow PM pipelines: continue (update PRD Done/Next→QA→create issues for next phase),",
-      "prd-qa (refine PRD), create-issues (decompose PRD into GitHub issues),",
-      "create-issue (single issue from a feature idea).",
-      "Each pipeline spawns specialized sub-agents with isolated context.",
-    ].join(" "),
-    parameters: ForgeflowPmParams as AnyCtx,
-
-    async execute(
-      _toolCallId: string,
-      _params: unknown,
-      signal: AbortSignal | undefined,
-      onUpdate: AnyCtx,
-      ctx: AnyCtx,
-    ) {
-      const params = _params as ForgeflowPmInput;
-      const cwd = ctx.cwd as string;
-      const sig = signal ?? new AbortController().signal;
-
-      try {
-        switch (params.pipeline) {
-          case "continue":
-            return await runContinue(cwd, params.issue ?? "", params.maxIterations ?? 10, sig, onUpdate, ctx);
-          case "prd-qa":
-            return await runPrdQa(cwd, params.maxIterations ?? 10, sig, onUpdate, ctx);
-          case "create-issues":
-            return await runCreateIssues(cwd, sig, onUpdate, ctx);
-          case "create-issue":
-            return await runCreateIssue(cwd, params.issue ?? "", sig, onUpdate, ctx);
-          default:
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Unknown pipeline: ${params.pipeline}. Use: continue, prd-qa, create-issues, create-issue`,
-                },
-              ],
-              details: { pipeline: params.pipeline, stages: [] } as PipelineDetails,
-            };
-        }
-      } finally {
-        if (ctx.hasUI) {
-          ctx.ui.setStatus("forgeflow-pm", undefined);
-          ctx.ui.setWidget("forgeflow-pm", undefined);
-        }
-      }
-    },
-
-    renderCall(_args: unknown, theme: AnyCtx) {
-      const args = _args as ForgeflowPmInput;
-      const pipeline = args.pipeline || "?";
-      let text = theme.fg("toolTitle", theme.bold("forgeflow-pm ")) + theme.fg("accent", pipeline);
-      if (args.issue) text += theme.fg("dim", ` "${args.issue}"`);
-      if (args.maxIterations) text += theme.fg("muted", ` (max ${args.maxIterations})`);
-      return new Text(text, 0, 0);
-    },
-
-    renderResult(result: AnyCtx, { expanded }: { expanded: boolean }, theme: AnyCtx) {
-      const details = result.details as PipelineDetails | undefined;
-      if (!details || details.stages.length === 0) {
-        const text = result.content[0];
-        return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
-      }
-
-      if (expanded) {
-        return renderExpanded(details, theme);
-      }
-      return renderCollapsed(details, theme);
-    },
-  });
-}
-
-// ─── Rendering ────────────────────────────────────────────────────────
-
-function renderExpanded(details: PipelineDetails, theme: AnyCtx) {
-  const container = new Container();
-  container.addChild(
-    new Text(theme.fg("toolTitle", theme.bold("forgeflow-pm ")) + theme.fg("accent", details.pipeline), 0, 0),
-  );
-  container.addChild(new Spacer(1));
-
-  for (const stage of details.stages) {
-    const icon = stageIcon(stage, theme);
-    container.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(stage.name))}`, 0, 0));
-
-    const items = getDisplayItems(stage.messages);
-    for (const item of items) {
-      if (item.type === "toolCall") {
-        container.addChild(
-          new Text(
-            `  ${theme.fg("muted", "→ ")}${formatToolCallShort(item.name, item.args, theme.fg.bind(theme))}`,
-            0,
-            0,
-          ),
-        );
-      }
-    }
-
-    const output = getFinalOutput(stage.messages);
-    if (output) {
-      container.addChild(new Spacer(1));
-      try {
-        const { getMarkdownTheme } = require("@mariozechner/pi-coding-agent");
-        container.addChild(new Markdown(output.trim(), 0, 0, getMarkdownTheme()));
-      } catch {
-        container.addChild(new Text(theme.fg("toolOutput", output.slice(0, 500)), 0, 0));
-      }
-    }
-
-    const usageStr = formatUsage(stage.usage, stage.model);
-    if (usageStr) container.addChild(new Text(theme.fg("dim", usageStr), 0, 0));
-    container.addChild(new Spacer(1));
-  }
-
-  return container;
-}
-
-function renderCollapsed(details: PipelineDetails, theme: AnyCtx) {
-  let text = theme.fg("toolTitle", theme.bold("forgeflow-pm ")) + theme.fg("accent", details.pipeline);
-  for (const stage of details.stages) {
-    const icon = stageIcon(stage, theme);
-    text += `\n  ${icon} ${theme.fg("toolTitle", stage.name)}`;
-
-    if (stage.status === "running") {
-      const items = getDisplayItems(stage.messages);
-      const last = items.filter((i) => i.type === "toolCall").slice(-3);
-      for (const item of last) {
-        if (item.type === "toolCall") {
-          text += `\n    ${theme.fg("muted", "→ ")}${formatToolCallShort(item.name, item.args, theme.fg.bind(theme))}`;
-        }
-      }
-    } else if (stage.status === "done" || stage.status === "failed") {
-      const preview = stage.output.split("\n")[0]?.slice(0, 80) || "(no output)";
-      text += theme.fg("dim", ` ${preview}`);
-      const usageStr = formatUsage(stage.usage, stage.model);
-      if (usageStr) text += ` ${theme.fg("dim", usageStr)}`;
-    }
-  }
-  return new Text(text, 0, 0);
-}
-
-function stageIcon(stage: StageResult, theme: AnyCtx): string {
-  return stage.status === "done"
-    ? theme.fg("success", "✓")
-    : stage.status === "running"
-      ? theme.fg("warning", "⟳")
-      : stage.status === "failed"
-        ? theme.fg("error", "✗")
-        : theme.fg("muted", "○");
-}
-
-// ─── Extension entry point ────────────────────────────────────────────
-
-const extension: (pi: ExtensionAPI) => void = (pi) => {
-  registerForgeflowPmTool(pi);
-
-  pi.registerCommand("continue", {
-    description:
-      'Update PRD with Done/Next based on codebase state, QA the Next section, then create issues. Usage: /continue ["description of next phase"]',
-    handler: async (args) => {
-      const trimmed = args.trim().replace(/^"(.*)"$/, "$1");
-      const descPart = trimmed ? `, issue="${trimmed}"` : "";
-      pi.sendUserMessage(
-        `Call the forgeflow-pm tool now with these exact parameters: pipeline="continue"${descPart}. Do not interpret the description — pass it as-is.`,
-      );
-    },
-  });
-
-  pi.registerCommand("prd-qa", {
-    description: "Refine PRD.md via critic → architect → integrator loop",
-    handler: async (args) => {
-      const maxIter = parseInt(args, 10) || 10;
-      pi.sendUserMessage(
-        `Call the forgeflow-pm tool now with these exact parameters: pipeline="prd-qa", maxIterations=${maxIter}.`,
-      );
-    },
-  });
-
-  pi.registerCommand("create-issues", {
-    description: "Decompose PRD.md into vertical-slice GitHub issues",
-    handler: async () => {
-      pi.sendUserMessage(`Call the forgeflow-pm tool now with these exact parameters: pipeline="create-issues".`);
-    },
-  });
-
-  pi.registerCommand("create-issue", {
-    description: "Create a single GitHub issue from a feature idea",
-    handler: async (args) => {
-      if (!args.trim()) {
-        pi.sendUserMessage('I need a feature idea. Usage: /create-issue "Add user authentication"');
-        return;
-      }
-      pi.sendUserMessage(
-        `Call the forgeflow-pm tool now with these exact parameters: pipeline="create-issue", issue="${args.trim()}". Do not interpret the issue text — pass it as-is.`,
-      );
-    },
-  });
-};
-
-export default extension;

package/src/pipelines/continue.ts

@@ -1,138 +0,0 @@
-import * as fs from "node:fs";
-import {
-  type AnyCtx,
-  emptyStage,
-  runAgent,
-  type StageResult,
-  signalExists,
-  TOOLS_ALL,
-  TOOLS_NO_EDIT,
-} from "@callumvass/forgeflow-shared";
-import { AGENTS_DIR } from "../resolve.js";
-
-/**
- * Continue pipeline: update PRD with Done/Next, run QA loop, create issues.
- */
-export async function runContinue(
-  cwd: string,
-  description: string,
-  maxIterations: number,
-  signal: AbortSignal,
-  onUpdate: AnyCtx,
-  ctx: AnyCtx,
-) {
-  if (!fs.existsSync(`${cwd}/PRD.md`)) {
-    return {
-      content: [{ type: "text" as const, text: "PRD.md not found." }],
-      details: { pipeline: "continue", stages: [] },
-    };
-  }
-
-  const stages: StageResult[] = [];
-  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "continue", onUpdate };
-
-  // Phase 1: Update PRD with Done/Next structure
-  stages.push(emptyStage("prd-architect"));
-  const updatePrompt = `You are updating a PRD for the next phase of work on an existing project.
-
-1. Read PRD.md to understand the product spec.
-2. Explore the codebase thoroughly — file structure, existing features, git log, tests, what's actually built.
-3. Compare what the PRD describes vs what exists in code.
-4. Rewrite PRD.md with this structure:
-   - Keep the Problem Statement, Goals, Tech Stack, and other top-level sections
-   - Add or update a \`## Done\` section: a concise summary of what's already built (based on your codebase exploration, not just what the PRD previously said). Keep it brief — bullet points or short paragraphs describing completed user-facing capabilities.
-   - Add or update a \`## Next\` section: the upcoming work.${description ? ` The user wants the next phase to focus on: ${description}` : ""}
-   - The \`## Next\` section should follow all PRD quality standards — user stories, functional requirements, edge cases, scope boundaries.
-   - Remove any phase markers like 'Phase 1 (Complete)' — use Done/Next instead.
-
-5. Keep the total PRD under 200 lines. The Done section should be especially concise — it's context, not spec.
-
-CRITICAL RULES:
-- Do NOT include code blocks, type definitions, or implementation detail.
-- The Done section summarizes capabilities ('users can create runs and see streaming output'), not architecture ('Hono server with SSE endpoints').
-- The Next section must be specific enough to create vertical-slice issues from.
-- If no description was provided for Next, infer it from the existing PRD's roadmap, scope boundaries, or TODO items.`;
-
-  const archResult = await runAgent("prd-architect", updatePrompt, { ...opts, tools: TOOLS_ALL });
-  if (archResult.status === "failed") {
-    return {
-      content: [{ type: "text" as const, text: `PRD update failed.\nStderr: ${archResult.stderr.slice(0, 300)}` }],
-      details: { pipeline: "continue", stages },
-      isError: true,
-    };
-  }
-
-  // Approval gate after PRD update
-  if (ctx.hasUI) {
-    const prdContent = fs.readFileSync(`${cwd}/PRD.md`, "utf-8");
-    const edited = await ctx.ui.editor("Review updated PRD (Done/Next structure)", prdContent);
-    if (edited != null && edited !== prdContent) {
-      fs.writeFileSync(`${cwd}/PRD.md`, edited, "utf-8");
-    }
-    const action = await ctx.ui.select("PRD updated with Done/Next. What next?", ["Continue to QA", "Stop here"]);
-    if (action === "Stop here" || action == null) {
-      return {
-        content: [{ type: "text" as const, text: "PRD updated. Stopped before QA." }],
-        details: { pipeline: "continue", stages },
-      };
-    }
-  }
-
-  // Phase 2: PRD QA loop on the Next section
-  for (let i = 1; i <= maxIterations; i++) {
-    stages.push(emptyStage("prd-critic"));
-    const criticResult = await runAgent(
-      "prd-critic",
-      "Review PRD.md for completeness — focus on the ## Next section. If it needs refinement, create QUESTIONS.md. If it's complete, do NOT create QUESTIONS.md.",
-      { ...opts, tools: TOOLS_NO_EDIT },
-    );
-
-    if (!signalExists(cwd, "questions")) {
-      if (criticResult.status === "failed") {
-        return {
-          content: [{ type: "text" as const, text: `Critic failed.\nStderr: ${criticResult.stderr.slice(0, 300)}` }],
-          details: { pipeline: "continue", stages },
-          isError: true,
-        };
-      }
-      break;
-    }
-
-    stages.push(emptyStage("prd-architect"));
-    await runAgent(
-      "prd-architect",
-      "Read PRD.md and answer all questions in QUESTIONS.md. Write answers inline in QUESTIONS.md.",
-      { ...opts, tools: TOOLS_ALL },
-    );
-
-    stages.push(emptyStage("prd-integrator"));
-    await runAgent(
-      "prd-integrator",
-      "Incorporate answers from QUESTIONS.md into PRD.md, then delete QUESTIONS.md.",
-      opts,
-    );
-
-    if (ctx.hasUI) {
-      const prdContent = fs.readFileSync(`${cwd}/PRD.md`, "utf-8");
-      const edited = await ctx.ui.editor(`QA iteration ${i} — Review PRD`, prdContent);
-      if (edited != null && edited !== prdContent) {
-        fs.writeFileSync(`${cwd}/PRD.md`, edited, "utf-8");
-      }
-      const action = await ctx.ui.select("PRD updated. What next?", ["Continue refining", "Accept PRD"]);
-      if (action === "Accept PRD" || action == null) break;
-    }
-  }
-
-  // Phase 3: Create issues from the Next section
-  stages.push(emptyStage("issue-creator"));
-  await runAgent(
-    "issue-creator",
-    "Decompose PRD.md into vertical-slice GitHub issues. Focus on the ## Next section — the ## Done section is context only. Read the issue-template skill for the standard format.",
-    { ...opts, tools: TOOLS_NO_EDIT },
-  );
-
-  return {
-    content: [{ type: "text" as const, text: "Continue pipeline complete. PRD updated, QA'd, and issues created." }],
-    details: { pipeline: "continue", stages },
-  };
-}

package/src/pipelines/create-issues.ts

@@ -1,45 +0,0 @@
-import * as fs from "node:fs";
-import { type AnyCtx, emptyStage, runAgent, TOOLS_NO_EDIT } from "@callumvass/forgeflow-shared";
-import { AGENTS_DIR } from "../resolve.js";
-
-export async function runCreateIssue(cwd: string, idea: string, signal: AbortSignal, onUpdate: AnyCtx, _ctx: AnyCtx) {
-  if (!idea) {
-    return {
-      content: [{ type: "text" as const, text: "No feature idea provided." }],
-      details: { pipeline: "create-issue", stages: [] },
-    };
-  }
-
-  const stages = [emptyStage("single-issue-creator")];
-  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "create-issue", onUpdate };
-
-  await runAgent("single-issue-creator", idea, { ...opts, tools: TOOLS_NO_EDIT });
-
-  return {
-    content: [{ type: "text" as const, text: "Issue created." }],
-    details: { pipeline: "create-issue", stages },
-  };
-}
-
-export async function runCreateIssues(cwd: string, signal: AbortSignal, onUpdate: AnyCtx, _ctx: AnyCtx) {
-  if (!fs.existsSync(`${cwd}/PRD.md`)) {
-    return {
-      content: [{ type: "text" as const, text: "PRD.md not found." }],
-      details: { pipeline: "create-issues", stages: [] },
-    };
-  }
-
-  const stages = [emptyStage("issue-creator")];
-  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "create-issues", onUpdate };
-
-  await runAgent(
-    "issue-creator",
-    "Decompose PRD.md into vertical-slice GitHub issues. Read the issue-template skill for the standard format.",
-    { ...opts, tools: TOOLS_NO_EDIT },
-  );
-
-  return {
-    content: [{ type: "text" as const, text: "Issue creation complete." }],
-    details: { pipeline: "create-issues", stages },
-  };
-}

package/src/pipelines/prd-qa.ts

@@ -1,88 +0,0 @@
-import * as fs from "node:fs";
-import {
-  type AnyCtx,
-  emptyStage,
-  runAgent,
-  type StageResult,
-  signalExists,
-  TOOLS_ALL,
-  TOOLS_NO_EDIT,
-} from "@callumvass/forgeflow-shared";
-import { AGENTS_DIR } from "../resolve.js";
-
-export async function runPrdQa(cwd: string, maxIterations: number, signal: AbortSignal, onUpdate: AnyCtx, ctx: AnyCtx) {
-  if (!fs.existsSync(`${cwd}/PRD.md`)) {
-    return {
-      content: [{ type: "text" as const, text: "PRD.md not found." }],
-      details: { pipeline: "prd-qa", stages: [] },
-    };
-  }
-
-  const stages: StageResult[] = [];
-  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "prd-qa", onUpdate };
-
-  for (let i = 1; i <= maxIterations; i++) {
-    // Critic
-    stages.push(emptyStage("prd-critic"));
-    const criticResult = await runAgent(
-      "prd-critic",
-      "Review PRD.md for completeness. If it needs refinement, create QUESTIONS.md. If it's complete, do NOT create QUESTIONS.md.",
-      { ...opts, tools: TOOLS_NO_EDIT },
-    );
-
-    // No QUESTIONS.md = critic considers PRD complete
-    if (!signalExists(cwd, "questions")) {
-      if (criticResult.status === "failed") {
-        return {
-          content: [{ type: "text" as const, text: `Critic failed.\nStderr: ${criticResult.stderr.slice(0, 300)}` }],
-          details: { pipeline: "prd-qa", stages },
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: "text" as const, text: "PRD refinement complete. Ready for /create-issues." }],
-        details: { pipeline: "prd-qa", stages },
-      };
-    }
-
-    // Architect
-    stages.push(emptyStage("prd-architect"));
-    await runAgent(
-      "prd-architect",
-      "Read PRD.md and answer all questions in QUESTIONS.md. Write answers inline in QUESTIONS.md.",
-      { ...opts, tools: TOOLS_ALL },
-    );
-
-    // Integrator — incorporate answers into PRD before approval gate
-    stages.push(emptyStage("prd-integrator"));
-    await runAgent(
-      "prd-integrator",
-      "Incorporate answers from QUESTIONS.md into PRD.md, then delete QUESTIONS.md.",
-      opts,
-    );
-
-    // Approval gate — show PRD in editor, user can review/edit then decide
-    if (ctx.hasUI) {
-      const prdContent = fs.readFileSync(`${cwd}/PRD.md`, "utf-8");
-      const edited = await ctx.ui.editor(`Iteration ${i} — Review PRD (edit or close to continue)`, prdContent);
-
-      // If user edited, write changes back
-      if (edited != null && edited !== prdContent) {
-        fs.writeFileSync(`${cwd}/PRD.md`, edited, "utf-8");
-      }
-
-      const action = await ctx.ui.select("PRD updated. What next?", ["Continue refining", "Accept PRD"]);
-      if (action === "Accept PRD" || action == null) {
-        return {
-          content: [{ type: "text" as const, text: "PRD accepted." }],
-          details: { pipeline: "prd-qa", stages },
-        };
-      }
-    }
-  }
-
-  return {
-    content: [{ type: "text" as const, text: `PRD refinement did not complete after ${maxIterations} iterations.` }],
-    details: { pipeline: "prd-qa", 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/tsconfig.json

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