@signalridge/pi-workflows 0.2.0

package/src/synthesis.ts

@@ -0,0 +1,95 @@
+import type { WorkflowRun, WorkflowTaskResult } from "./journal.js";
+import type { WorkflowDefinition, WorkflowTask } from "./schema.js";
+
+export const MAX_TASK_RESULT_CHARS = 6_000;
+export const MAX_SYNTHESIS_INSTRUCTION_CHARS = 8_000;
+export const MAX_SYNTHESIS_INPUT_CHARS = 48_000;
+
+function cap(value: string, limit: number): { text: string; truncated: boolean } {
+  if (value.length <= limit) return { text: value, truncated: false };
+  const marker = "\n…[truncated]";
+  const contentLimit = Math.max(0, limit - marker.length);
+  return { text: `${value.slice(0, contentLimit)}${marker}`, truncated: true };
+}
+
+/** Build bounded, labeled synthesis context without concatenating full transcripts. */
+export function buildSynthesisPrompt(
+  definition: WorkflowDefinition,
+  run: WorkflowRun,
+  tasks: readonly WorkflowTask[] = definition.tasks,
+): string {
+  if (!definition.synthesis) throw new Error("workflow has no synthesis definition");
+
+  const instruction = cap(definition.synthesis.prompt, MAX_SYNTHESIS_INSTRUCTION_CHARS);
+  const chunks: string[] = [instruction.text, "", "Workflow task results:"];
+  let total = chunks.join("\n").length;
+  let aggregateTruncated = false;
+
+  for (const task of tasks) {
+    const result = run.taskResults[task.id];
+    const text = result?.text ?? "(no result)";
+    const bounded = cap(text, MAX_TASK_RESULT_CHARS);
+    const pointers = [
+      result?.agentId ? `agent_id=${result.agentId}` : "agent_id=unknown",
+      result?.outputFile ? `transcript=${result.outputFile}` : undefined,
+      result?.tokenCount !== undefined ? `token_count=${result.tokenCount}` : undefined,
+    ]
+      .filter((value): value is string => value !== undefined)
+      .join(" ");
+    const block = [
+      `### ${task.id} — ${task.description}`,
+      `status=${result?.status ?? run.taskStatus[task.id]} ${pointers}`,
+      bounded.truncated ? "result_truncated=true" : "result_truncated=false",
+      bounded.text,
+    ].join("\n");
+    if (total + block.length + 2 > MAX_SYNTHESIS_INPUT_CHARS) {
+      aggregateTruncated = true;
+      break;
+    }
+    chunks.push("", block);
+    total += block.length + 2;
+  }
+
+  let output = chunks.join("\n");
+  if (aggregateTruncated) {
+    const marker = "\n\n[aggregate synthesis input truncated: additional task results omitted]";
+    if (output.length + marker.length <= MAX_SYNTHESIS_INPUT_CHARS) {
+      output += marker;
+    } else {
+      output = `${output.slice(0, MAX_SYNTHESIS_INPUT_CHARS - marker.length)}${marker}`;
+    }
+  }
+  return cap(output, MAX_SYNTHESIS_INPUT_CHARS).text;
+}
+
+export function resultFromLifecycle(
+  status: "completed" | "failed" | "stopped",
+  agentId: string | undefined,
+  result: unknown,
+  error: unknown,
+  compactionCount: number,
+  updatedAt = Date.now(),
+  outputFile: unknown = undefined,
+  tokenCount: unknown = undefined,
+): WorkflowTaskResult {
+  const raw = typeof result === "string" ? result : "";
+  const bounded = cap(raw, MAX_TASK_RESULT_CHARS);
+  const errorText = typeof error === "string" && error.length > 0 ? error.slice(0, 2_000) : undefined;
+  const boundedOutputFile =
+    typeof outputFile === "string" && outputFile.length > 0 ? outputFile.slice(0, 2_000) : undefined;
+  const boundedTokenCount =
+    typeof tokenCount === "number" && Number.isFinite(tokenCount) && tokenCount > 0
+      ? Math.floor(tokenCount)
+      : undefined;
+  return {
+    status,
+    ...(agentId ? { agentId } : {}),
+    ...(bounded.text ? { text: bounded.text } : {}),
+    ...(errorText ? { error: errorText } : {}),
+    ...(boundedOutputFile ? { outputFile: boundedOutputFile } : {}),
+    ...(boundedTokenCount === undefined ? {} : { tokenCount: boundedTokenCount }),
+    compactionCount,
+    ...(bounded.truncated ? { truncated: true } : {}),
+    updatedAt,
+  };
+}

package/src/ui.ts

@@ -0,0 +1,142 @@
+import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
+import type { WorkflowEngine, WorkflowSummary } from "./engine.js";
+
+function elapsed(ms: number): string {
+  const seconds = Math.floor(ms / 1_000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m ${seconds % 60}s`;
+}
+
+export function formatWorkflowRunLabel(run: WorkflowSummary): string {
+  const phases = run.phaseCount > 0 ? ` · phases ${run.completedPhases}/${run.phaseCount}` : "";
+  const tokens = run.tokenCount === undefined ? "" : ` · ${run.tokenCount} tokens`;
+  return `${run.name} · ${run.status}${phases} · ${run.completedTasks}/${run.taskCount} tasks · ${elapsed(run.elapsedMs)}${tokens}`;
+}
+
+export function formatWorkflowDetail(engine: WorkflowEngine, runId: string): string {
+  const run = engine.getRun(runId);
+  if (!run) return "Workflow run is no longer available.";
+  const tokenValues = [...Object.values(run.taskResults), ...(run.synthesisResult ? [run.synthesisResult] : [])]
+    .map((result) => result.tokenCount)
+    .filter((value): value is number => value !== undefined);
+  const tokenCount = tokenValues.length > 0 ? tokenValues.reduce((total, value) => total + value, 0) : undefined;
+  const lines = [
+    `${run.definition.name} [${run.status}]`,
+    `run: ${run.runId}`,
+    `elapsed: ${elapsed(Math.max(0, (run.status === "completed" || run.status === "failed" || run.status === "stopped" ? run.updatedAt : Date.now()) - run.startedAt))}`,
+    "",
+    ...(tokenCount === undefined ? [] : [`tokens: ${tokenCount}`]),
+  ];
+  for (const phase of run.definition.phases) {
+    lines.push(`Phase: ${phase.title}`);
+    for (const task of run.definition.tasks.filter((candidate) => candidate.phase === phase.id)) {
+      const status = run.taskStatus[task.id] ?? "pending";
+      const agent = run.agentIds[task.id] ? ` agent=${run.agentIds[task.id]}` : "";
+      const compact = run.compactions[task.id] ? ` compactions=${run.compactions[task.id]}` : "";
+      lines.push(`  ${status.padEnd(11)} ${task.id}${agent}${compact}`);
+      const result = run.taskResults[task.id];
+      if (result?.error) lines.push(`    error: ${result.error.slice(0, 300)}`);
+      if (result?.text) lines.push(`    result: ${result.text.replaceAll("\n", " ").slice(0, 300)}`);
+    }
+  }
+  const unphased = run.definition.tasks.filter((task) => task.phase === undefined);
+  if (unphased.length > 0) {
+    lines.push("Tasks:");
+    for (const task of unphased) {
+      const status = run.taskStatus[task.id] ?? "pending";
+      const agent = run.agentIds[task.id] ? ` agent=${run.agentIds[task.id]}` : "";
+      lines.push(`  ${status.padEnd(11)} ${task.id}${agent}`);
+    }
+  }
+  lines.push("", "Live agent conversations remain available through pi-subagents FleetView.");
+  if (run.error) lines.push(`Error: ${run.error.slice(0, 500)}`);
+  return lines.join("\n");
+}
+
+async function selectList<T>(
+  ctx: ExtensionCommandContext,
+  title: string,
+  items: SelectItem[],
+  renderExtra: (theme: Pick<Theme, "fg">) => string,
+): Promise<T | undefined> {
+  if (ctx.mode !== "tui") return undefined;
+  return ctx.ui.custom<T | undefined>((_tui, theme, _keybindings, done) => {
+    const container = new Container();
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    container.addChild(new Text(theme.fg("accent", theme.bold(title)), 1, 0));
+    container.addChild(new Text(theme.fg("dim", renderExtra(theme)), 1, 0));
+    const list = new SelectList(items, Math.min(12, Math.max(1, items.length)), {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.fg("accent", text),
+      description: (text) => theme.fg("muted", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("warning", text),
+    });
+    list.onSelect = (item) => done(item.value as T);
+    list.onCancel = () => done(undefined);
+    container.addChild(list);
+    container.addChild(new Text(theme.fg("dim", "↑↓ select · enter confirm · esc back"), 1, 0));
+    container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    return {
+      render: (width) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data) => list.handleInput(data),
+    };
+  });
+}
+
+/** Interactive `/workflows` navigator. TUI-only by design. */
+export async function showWorkflowNavigator(ctx: ExtensionCommandContext, engine: WorkflowEngine): Promise<void> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("/workflows requires TUI mode; use workflow_control for machine-readable access.", "warning");
+    return;
+  }
+  while (true) {
+    const runs = engine.list();
+    const selected = await selectList<string>(
+      ctx,
+      "Workflow runs",
+      runs.map((run) => ({
+        value: run.runId,
+        label: formatWorkflowRunLabel(run),
+        description: run.error?.slice(0, 120),
+      })),
+      (theme) =>
+        runs.length > 0
+          ? theme.fg("dim", "Select a run to inspect.")
+          : theme.fg("muted", "No workflow runs in this session."),
+    );
+    if (!selected) return;
+    while (true) {
+      const run = engine.get(selected);
+      if (!run) break;
+      const action = await selectList<string>(
+        ctx,
+        `${run.name} · ${run.status}`,
+        [
+          { value: "refresh", label: "Refresh" },
+          ...(run.status === "running" ? [{ value: "pause", label: "Pause" }] : []),
+          ...(run.status === "paused" || run.status === "interrupted" ? [{ value: "resume", label: "Resume" }] : []),
+          ...(!["completed", "failed", "stopped"].includes(run.status) ? [{ value: "stop", label: "Stop" }] : []),
+          { value: "back", label: "Back" },
+        ],
+        () => formatWorkflowDetail(engine, selected),
+      );
+      if (!action || action === "back") break;
+      if (action === "refresh") continue;
+      if (action === "stop") {
+        const confirmed = await ctx.ui.confirm("Stop workflow", `Stop ${run.name}? The run will be non-resumable.`);
+        if (!confirmed) continue;
+      }
+      try {
+        await engine.control(action as "pause" | "resume" | "stop", selected);
+        ctx.ui.notify(`Workflow ${action} requested.`, "info");
+      } catch (error: unknown) {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      }
+    }
+  }
+}