supipowers 1.5.3 → 2.0.1

package/src/ultraplan/authoring/command-handlers.ts

@@ -0,0 +1,339 @@
+/**
+ * Slash-command handlers for the multi-stage authoring pipeline.
+ *
+ * Each exported `handle*` function corresponds to a `/supi:ultraplan <subcommand>`. They wire
+ * the picker, TUI input, and pipeline driver so the command file (`src/commands/ultraplan.ts`)
+ * stays focused on routing.
+ *
+ * These handlers are deliberately UI-light: they call `ctx.ui.input` and `ctx.ui.select` for
+ * the user gate moments specified in the plan; everything else is delegated to
+ * `runPipelineUntilGate` and the per-stage runners.
+ */
+
+import * as fs from "node:fs";
+
+import type { Platform } from "../../platform/types.js";
+import { notifyError, notifyInfo, notifyWarning } from "../../notifications/renderer.js";
+import { loadModelConfig } from "../../config/model-config.js";
+import {
+  getUltraplanAuthoringDir,
+  getUltraplanSessionDir,
+} from "../project-paths.js";
+import {
+  ULTRAPLAN_AUTHORED_JSON_FILENAME,
+} from "../project-paths.js";
+import { loadUltraPlanIndex, saveUltraPlanManifest } from "../storage.js";
+import {
+  listInFlightAuthoringSessions,
+  runPipelineUntilGate,
+  runStage,
+  type PipelineGateMode,
+} from "./pipeline.js";
+import type {
+  UltraPlanAuthoringStage,
+  UltraPlanManifest,
+} from "../../types.js";
+import path from "node:path";
+
+const ULTRAPLAN_ID_PREFIX = "up-";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function newAuthoringSessionId(now: () => Date = () => new Date()): string {
+  // Mirrors the existing convention in authoring-wizard.ts: `up-<ms>-<rand>`.
+  const ms = now().getTime();
+  const rand = Math.floor(Math.random() * 0xffffff).toString(16).padStart(6, "0");
+  return `${ULTRAPLAN_ID_PREFIX}${ms.toString(36)}-${rand}`;
+}
+
+function projectName(cwd: string): string {
+  return path.basename(path.resolve(cwd));
+}
+
+function makeBootstrapManifest(sessionId: string, projName: string): UltraPlanManifest {
+  const nowIso = new Date().toISOString();
+  return {
+    sessionId,
+    projectName: projName,
+    title: "(authoring)",
+    authored: { json: ULTRAPLAN_AUTHORED_JSON_FILENAME, markdown: undefined as never },
+    state: "ready",
+    cursor: null,
+    lastCompleted: null,
+    progress: { total: 0, terminal: 0, blocked: 0 },
+    stacks: [],
+    blocker: null,
+    reviews: [],
+    createdAt: nowIso,
+    updatedAt: nowIso,
+  };
+}
+
+function isInFlightStage(stage: UltraPlanAuthoringStage): boolean {
+  return stage !== "approve";
+}
+
+function readSessionsFromIndex(platform: Platform, cwd: string): string[] {
+  const index = loadUltraPlanIndex(platform.paths, cwd);
+  if (!index.ok) return [];
+  return index.value.sessions.map((s) => s.sessionId);
+}
+
+function isSessionPromoted(platform: Platform, cwd: string, sessionId: string): boolean {
+  // A promoted session has its canonical authored.json in the session dir.
+  const dir = getUltraplanSessionDir(platform.paths, cwd, sessionId);
+  return fs.existsSync(path.join(dir, ULTRAPLAN_AUTHORED_JSON_FILENAME));
+}
+
+// ---------------------------------------------------------------------------
+// Bare-entry handler
+// ---------------------------------------------------------------------------
+
+export interface BareEntryInput {
+  platform: Platform;
+  ctx: any;
+}
+
+/**
+ * Bare `/supi:ultraplan` invocation: detect in-flight authoring sessions, offer Resume /
+ * Start fresh / Cancel, then drive the pipeline.
+ */
+export async function handleBareEntry(input: BareEntryInput): Promise<void> {
+  const { platform, ctx } = input;
+  if (!ctx.hasUI) {
+    notifyWarning(ctx, "UltraPlan authoring requires interactive mode");
+    return;
+  }
+
+  const allSessionIds = readSessionsFromIndex(platform, ctx.cwd);
+  const inFlight = listInFlightAuthoringSessions(platform.paths, ctx.cwd, allSessionIds)
+    .filter((s) => isInFlightStage(s.stage) && !isSessionPromoted(platform, ctx.cwd, s.sessionId));
+
+  // Step 1: in-flight picker.
+  let resumeSessionId: string | null = null;
+  if (inFlight.length > 0) {
+    const options = [
+      ...inFlight.map((s) => ({
+        label: `Resume ${s.sessionId} (stage: ${s.stage}, status: ${s.status})`,
+        value: `resume:${s.sessionId}`,
+      })),
+      { label: "Start fresh", value: "fresh" },
+      { label: "Cancel", value: "cancel" },
+    ];
+    const choice = await ctx.ui.select("In-flight UltraPlan authoring sessions", options);
+    if (!choice || choice === "cancel") return;
+    if (choice.startsWith("resume:")) resumeSessionId = choice.slice("resume:".length);
+  }
+
+  if (resumeSessionId) {
+    await driveAuthoringPipeline({
+      platform,
+      ctx,
+      sessionId: resumeSessionId,
+      seedPrompt: "",
+      gates: "default",
+    });
+    return;
+  }
+
+  // Step 2: capture seed prompt via TUI input.
+  const seed = await ctx.ui.input("What do you want to ship next?", {
+    multiline: true,
+    helpText: "Describe the work; press Enter to submit, Esc to cancel.",
+  });
+  if (!seed || seed.trim().length === 0) return;
+
+  const sessionId = newAuthoringSessionId();
+  // Bootstrap manifest so the authoring storage helpers have a host artifact.
+  const manifestSave = saveUltraPlanManifest(
+    platform.paths,
+    ctx.cwd,
+    sessionId,
+    makeBootstrapManifest(sessionId, projectName(ctx.cwd)),
+  );
+  if (!manifestSave.ok) {
+    notifyError(ctx, "Failed to create authoring session", manifestSave.error.message);
+    return;
+  }
+
+  await driveAuthoringPipeline({ platform, ctx, sessionId, seedPrompt: seed, gates: "default" });
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline driver wrapper (UI-aware loop)
+// ---------------------------------------------------------------------------
+
+interface DriveInput {
+  platform: Platform;
+  ctx: any;
+  sessionId: string;
+  seedPrompt: string;
+  gates: PipelineGateMode;
+  iteration?: number;
+}
+
+/**
+ * Run the pipeline driver in a loop until the session is approved, blocked, or the user
+ * cancels. Between gates, presents a `ctx.ui.confirm` to advance.
+ */
+export async function driveAuthoringPipeline(input: DriveInput): Promise<void> {
+  const modelConfig = loadModelConfig(input.platform.paths, input.ctx.cwd);
+  let attempts = 0;
+  while (attempts < 8) {
+    attempts += 1;
+    const outcome = await runPipelineUntilGate({
+      platform: input.platform,
+      paths: input.platform.paths,
+      cwd: input.ctx.cwd,
+      sessionId: input.sessionId,
+      modelConfig,
+      seedPrompt: input.seedPrompt,
+      gates: input.gates,
+      iteration: input.iteration ?? 1,
+    });
+
+    if (outcome.status === "completed" || outcome.status === "skipped") {
+      if (outcome.promoted) {
+        notifyInfo(input.ctx, "UltraPlan approved", `Session ${input.sessionId} is ready to run.`);
+      } else {
+        notifyInfo(input.ctx, "UltraPlan stage completed", `Stage ${outcome.stage} done.`);
+      }
+      return;
+    }
+
+    if (outcome.status === "failed" || outcome.status === "blocked") {
+      notifyError(input.ctx, `UltraPlan ${outcome.status} at ${outcome.stage}`, outcome.message ?? "");
+      return;
+    }
+
+    if (outcome.status === "awaiting-user") {
+      const advance = await input.ctx.ui.confirm
+        ? await input.ctx.ui.confirm(
+            `UltraPlan: ${outcome.stage} ready`,
+            `The ${outcome.stage} stage finished. Continue to the next stage?`,
+          )
+        : true;
+      if (!advance) {
+        notifyInfo(input.ctx, "UltraPlan paused", `Resume with /supi:ultraplan resume ${input.sessionId}`);
+        return;
+      }
+      continue;
+    }
+  }
+  notifyWarning(input.ctx, "UltraPlan: too many gates", "Driver loop hit its safety cap; resume to continue.");
+}
+
+// ---------------------------------------------------------------------------
+// Per-stage subcommand handlers
+// ---------------------------------------------------------------------------
+
+export async function handleStageSubcommand(
+  stage: UltraPlanAuthoringStage,
+  platform: Platform,
+  ctx: any,
+  args: string,
+): Promise<void> {
+  if (!ctx.hasUI) {
+    notifyWarning(ctx, "UltraPlan authoring requires interactive mode");
+    return;
+  }
+
+  const sessionId = args.trim() || (await pickInFlightSession(platform, ctx));
+  if (!sessionId) return;
+
+  const seedPrompt = stage === "intake"
+    ? (await ctx.ui.input("What do you want to ship next?", { multiline: true })) ?? ""
+    : "";
+
+  const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
+  const result = await runStage(stage, {
+    platform,
+    paths: platform.paths,
+    cwd: ctx.cwd,
+    sessionId,
+    modelConfig,
+    seedPrompt,
+  });
+
+  if (result.status === "completed" || result.status === "skipped") {
+    notifyInfo(ctx, `UltraPlan ${stage} done`, result.details ? JSON.stringify(result.details) : "");
+    return;
+  }
+  if (result.status === "awaiting-user") {
+    notifyInfo(ctx, `UltraPlan ${stage} awaiting user`, "Continue with the next stage when ready.");
+    return;
+  }
+  notifyError(ctx, `UltraPlan ${stage} ${result.status}`, result.error ?? result.blocker?.message ?? "");
+}
+
+async function pickInFlightSession(platform: Platform, ctx: any): Promise<string | null> {
+  const allSessionIds = readSessionsFromIndex(platform, ctx.cwd);
+  const inFlight = listInFlightAuthoringSessions(platform.paths, ctx.cwd, allSessionIds)
+    .filter((s) => !isSessionPromoted(platform, ctx.cwd, s.sessionId));
+  if (inFlight.length === 0) {
+    notifyWarning(ctx, "No in-flight authoring sessions", "Start one with /supi:ultraplan");
+    return null;
+  }
+  if (inFlight.length === 1) return inFlight[0]!.sessionId;
+  const choice = await ctx.ui.select(
+    "Pick an in-flight session",
+    inFlight.map((s) => ({ label: `${s.sessionId} (${s.stage})`, value: s.sessionId })),
+  );
+  return typeof choice === "string" ? choice : null;
+}
+
+// ---------------------------------------------------------------------------
+// Resume + plan + quick handlers
+// ---------------------------------------------------------------------------
+
+export async function handleResume(platform: Platform, ctx: any, args: string): Promise<void> {
+  const arg = args.trim();
+  if (arg.length > 0) {
+    const dir = getUltraplanAuthoringDir(platform.paths, ctx.cwd, arg);
+    if (!fs.existsSync(dir)) {
+      notifyError(ctx, "No authoring session", `No authoring directory found for ${arg}`);
+      return;
+    }
+    await driveAuthoringPipeline({ platform, ctx, sessionId: arg, seedPrompt: "", gates: "default" });
+    return;
+  }
+  // No id arg: pick from in-flight list.
+  const sessionId = await pickInFlightSession(platform, ctx);
+  if (!sessionId) return;
+  await driveAuthoringPipeline({ platform, ctx, sessionId, seedPrompt: "", gates: "default" });
+}
+
+export async function handlePlan(platform: Platform, ctx: any, args: string): Promise<void> {
+  if (!ctx.hasUI) {
+    notifyWarning(ctx, "UltraPlan authoring requires interactive mode");
+    return;
+  }
+  const tokens = args.trim().split(/\s+/).filter((t) => t.length > 0);
+  let gates: PipelineGateMode = "default";
+  const positional: string[] = [];
+  for (const tok of tokens) {
+    if (tok === "--auto") gates = "auto";
+    else if (tok === "--manual") gates = "manual";
+    else positional.push(tok);
+  }
+  let seed = positional.join(" ").trim();
+  if (seed.length === 0) {
+    seed = (await ctx.ui.input("What do you want to ship next?", { multiline: true })) ?? "";
+  }
+  if (seed.length === 0) return;
+
+  const sessionId = newAuthoringSessionId();
+  const manifestSave = saveUltraPlanManifest(
+    platform.paths,
+    ctx.cwd,
+    sessionId,
+    makeBootstrapManifest(sessionId, projectName(ctx.cwd)),
+  );
+  if (!manifestSave.ok) {
+    notifyError(ctx, "Failed to create authoring session", manifestSave.error.message);
+    return;
+  }
+  await driveAuthoringPipeline({ platform, ctx, sessionId, seedPrompt: seed, gates });
+}