@getpipher/armory-fleet 0.11.1 → 0.12.0

package/src/workflows/panel/workflows-items.ts

@@ -0,0 +1,150 @@
+// SPEC-6-3 §7/§10 — combined Workflows panel item + action model (pure functions).
+// Definitions first (sorted by source rank, then name), then runs (newest-first).
+import type { SelectItem } from "@earendil-works/pi-tui"
+
+import type { WorkflowDef } from "../registry.ts"
+import type { WorkflowRunState } from "../runtime/types.ts"
+
+export type WorkflowPanelItem =
+  | { kind: "definition"; definition: WorkflowDef }
+  | { kind: "run"; run: WorkflowRunState }
+
+export type WorkflowPanelAction =
+  | "run"
+  | "open"
+  | "pause"
+  | "resume"
+  | "stop"
+  | "save"
+  | "respond"
+  | "edit-resume"
+  | "view-result"
+  | "resume-unchanged"
+
+const SOURCE_RANK: Record<WorkflowDef["source"], number> = {
+  project: 0,
+  global: 1,
+  builtin: 2,
+}
+
+const RUN_STATUS_GLYPH: Record<WorkflowRunState["status"], string> = {
+  queued: "○",
+  running: "▶",
+  paused: "⏸",
+  checkpoint: "⏸",
+  completed: "✓",
+  failed: "✗",
+  aborted: "✗",
+  interrupted: "⚠",
+}
+
+const DESC_BOUND = 80
+const LOG_BOUND = 120
+
+function bound(text: string, max: number): string {
+  return text.length > max ? text.slice(0, max - 1) + "…" : text
+}
+
+function phaseStrip(phases: { title: string }[], current: string): string {
+  return phases.map((p) => (p.title === current ? `${p.title} ▶` : `${p.title} ○`)).join(" ")
+}
+
+function definitionLabel(def: WorkflowDef): string {
+  const desc = def.description ? ` — ${bound(def.description, DESC_BOUND)}` : ""
+  return `◇ ${def.name}  [${def.source}]${desc}`
+}
+
+function runLabel(state: WorkflowRunState): string {
+  const glyph = RUN_STATUS_GLYPH[state.status]
+  const strip = state.phases.length > 0 ? `  ${phaseStrip(state.phases, state.currentPhase)}` : ""
+  const tokens = state.tokenTotal > 0 ? ` · ${(state.tokenTotal / 1000).toFixed(1)}K tok` : ""
+  const cost = state.costTotal > 0 ? ` · $${state.costTotal.toFixed(2)}` : ""
+  const lastLog = state.logs.length > 0 ? `  ${bound(state.logs.at(-1) ?? "", LOG_BOUND)}` : ""
+  return `${glyph} ${state.runId}  [${state.status}]${strip}${tokens}${cost}${lastLog}`
+}
+
+export function buildWorkflowPanelItems(input: {
+  definitions: WorkflowDef[]
+  runs: WorkflowRunState[]
+}): SelectItem[] {
+  const sortedDefs = [...input.definitions].sort((a, b) => {
+    const rankDiff = SOURCE_RANK[a.source] - SOURCE_RANK[b.source]
+    if (rankDiff !== 0) return rankDiff
+    return a.name.localeCompare(b.name)
+  })
+
+  const sortedRuns = [...input.runs].sort((a, b) => b.startedAt - a.startedAt)
+
+  const defItems: SelectItem[] = sortedDefs.map((def) => ({
+    value: `definition:${def.name}`,
+    label: definitionLabel(def),
+  }))
+
+  const runItems: SelectItem[] = sortedRuns.map((r) => ({
+    value: `run:${r.runId}`,
+    label: runLabel(r),
+  }))
+
+  return [...defItems, ...runItems]
+}
+
+export function actionsForWorkflowItem(item: WorkflowPanelItem): WorkflowPanelAction[] {
+  if (item.kind === "definition") {
+    return ["run", "open"]
+  }
+
+  const status = item.run.status
+  switch (status) {
+    case "queued":
+      return ["open", "stop"]
+    case "running":
+      return ["open", "pause", "stop", "save"]
+    case "paused":
+      return ["open", "resume", "stop", "save"]
+    case "checkpoint":
+      return ["respond", "stop", "open"]
+    case "completed":
+      return ["open", "edit-resume", "save", "view-result"]
+    case "failed":
+      return ["open", "edit-resume", "save", "view-result"]
+    case "aborted":
+      return ["open", "edit-resume", "save", "view-result"]
+    case "interrupted":
+      return ["open", "edit-resume", "resume-unchanged", "stop", "save"]
+  }
+}
+
+export function parseWorkflowPanelKey(
+  value: string,
+): { kind: "definition"; name: string } | { kind: "run"; runId: string } {
+  if (value.startsWith("definition:")) {
+    return { kind: "definition", name: value.slice("definition:".length) }
+  }
+  if (value.startsWith("run:")) {
+    return { kind: "run", runId: value.slice("run:".length) }
+  }
+  throw new Error(`invalid workflow panel key: ${value}`)
+}
+
+// ── Backward-compat shim (Task 12 will rewire the panel to the new model) ──
+
+export interface WorkflowRunRow {
+  runId: string
+  name: string
+  status: "running" | "completed" | "failed" | "aborted" | "paused" | "checkpoint"
+  currentPhase: string
+  phases: { title: string }[]
+  agents: number
+  cached: number
+  reRun: number
+  tokens: number
+  cost: number
+}
+
+export function buildWorkflowsItems(runs: WorkflowRunRow[]): SelectItem[] {
+  return runs.map((r) => ({
+    id: r.runId,
+    label: `${RUN_STATUS_GLYPH[r.status] ?? "▶"} ${r.name}  [${r.status}]  ${phaseStrip(r.phases, r.currentPhase)} · ${r.agents} agents (${r.cached} cached, ${r.reRun} re-run) · ${(r.tokens / 1000).toFixed(1)}K tok · $${r.cost.toFixed(2)}`,
+    value: r.runId,
+  }))
+}

package/src/workflows/panel/workflows-rows.ts

@@ -0,0 +1,3 @@
+// SPEC-6-3 — row rendering helpers (pure). Re-exported for the panel; kept thin.
+export { buildWorkflowsItems, buildWorkflowPanelItems, actionsForWorkflowItem, parseWorkflowPanelKey } from "./workflows-items.ts"
+export type { WorkflowRunRow, WorkflowPanelItem, WorkflowPanelAction } from "./workflows-items.ts"

package/src/workflows/panel-host.ts

@@ -0,0 +1,179 @@
+// SPEC-6-3 §12 — panel host loop: consumes WorkflowPanelIntent from the panel
+// and drives editor/input/confirm around it. Never nests ui.editor inside ui.custom.
+import type { Theme } from "@earendil-works/pi-coding-agent"
+import type { Container } from "@earendil-works/pi-tui"
+import type { FleetPanelDeps } from "../panel/fleet-panel.ts"
+import type { WorkflowDef } from "./registry.ts"
+import type { WorkflowRunState } from "./runtime/types.ts"
+import { FleetPanel } from "../panel/fleet-panel.ts"
+
+export type WorkflowPanelIntent =
+  | { action: "close" }
+  | { action: "run"; definitionName: string; prompt: string }
+  | { action: "open-definition"; name: string }
+  | { action: "open-child"; runId: string; childRunId: string }
+  | { action: "edit-resume"; runId: string }
+  | { action: "save"; runId: string }
+  | { action: "view-result"; runId: string }
+  | { action: "respond"; runId: string }
+
+export interface WorkflowPanelHostContext {
+  custom: (factory: (tui: unknown, theme: Theme, kb: unknown, done: () => void) => Container) => void
+  editor: (initial: string) => Promise<string>
+  input: (prompt: string) => Promise<string>
+  confirm: (prompt: string) => Promise<boolean>
+  notify: (msg: string, type?: "info" | "warning" | "error") => void
+  sendUserMessage: (text: string) => void
+}
+
+const MAX_SOURCE_BYTES = 50_000
+const MAX_SOURCE_LINES = 2000
+
+function boundSource(source: string): string {
+  const lines = source.split("\n")
+  if (lines.length > MAX_SOURCE_LINES) {
+    return lines.slice(0, MAX_SOURCE_LINES).join("\n") + "\n… (truncated)"
+  }
+  if (source.length > MAX_SOURCE_BYTES) {
+    return source.slice(0, MAX_SOURCE_BYTES) + "… (truncated)"
+  }
+  return source
+}
+
+function boundResult(result: unknown): string {
+  let text: string
+  try {
+    text = JSON.stringify(result) ?? String(result)
+  } catch {
+    text = String(result)
+  }
+  return text.slice(0, MAX_SOURCE_BYTES)
+}
+
+export async function openWorkflowPanelLoop(
+  deps: FleetPanelDeps,
+  host: WorkflowPanelHostContext,
+): Promise<void> {
+  let running = true
+
+  while (running) {
+    const intent = await openPanelOnce(deps, host)
+
+    if (!intent || intent.action === "close") {
+      running = false
+      continue
+    }
+
+    switch (intent.action) {
+      case "run": {
+        if (intent.prompt.trim()) {
+          const instruction = `${intent.prompt}\n\nUse the fleet workflow tool (action:'workflow') with the '${intent.definitionName}' workflow to execute this.`
+          host.sendUserMessage(instruction)
+          running = false
+        } else {
+          await deps.workflowController.start({
+            workflowName: intent.definitionName,
+            mode: "checkpointed",
+          })
+        }
+        break
+      }
+
+      case "edit-resume": {
+        const run = deps.workflowController.getRun(intent.runId)
+        if (!run) {
+          host.notify(`run '${intent.runId}' not found`, "error")
+          break
+        }
+        const editedSource = await host.editor(run.script)
+        await deps.workflowController.editAndResume(intent.runId, editedSource, "checkpointed")
+        break
+      }
+
+      case "save": {
+        const run = deps.workflowController.getRun(intent.runId)
+        if (!run) {
+          host.notify(`run '${intent.runId}' not found`, "error")
+          break
+        }
+        const name = await host.input("Save-as name?")
+        let overwrite = false
+        const existing = deps.workflowRegistry.get(name)
+        const controllerWithCollision = deps.workflowController as unknown as { saveCollision?: boolean }
+        if (existing || controllerWithCollision.saveCollision) {
+          overwrite = await host.confirm(`Workflow '${name}' already exists. Overwrite?`)
+        }
+        deps.workflowController.save({ name, source: run.script, overwrite })
+        break
+      }
+
+      case "open-definition": {
+        const def = deps.workflowRegistry.get(intent.name)
+        if (!def) {
+          host.notify(`workflow '${intent.name}' not found`, "warning")
+          break
+        }
+        host.notify(`Source: ${def.name}\n${boundSource(def.sourceText)}`, "info")
+        break
+      }
+
+      case "open-child": {
+        host.notify(`Open child run '${intent.childRunId}' from '${intent.runId}' — use the Runs viewer.`, "info")
+        break
+      }
+
+      case "view-result": {
+        const run = deps.workflowController.getRun(intent.runId)
+        if (!run) {
+          host.notify(`run '${intent.runId}' not found`, "error")
+          break
+        }
+        const resultText = run.result !== undefined ? boundResult(run.result) : "(no result)"
+        const logText = run.logs.length > 0 ? run.logs.join("\n") : "(no logs)"
+        host.notify(`Result: ${resultText}\n\nLogs:\n${logText}`, "info")
+        break
+      }
+
+      case "respond": {
+        const shouldContinue = await host.confirm("Continue checkpoint?")
+        if (shouldContinue) {
+          deps.workflowController.respondToCheckpoint(intent.runId, { action: "continue" })
+        } else {
+          const feedback = await host.input("Revise feedback (blank to abort):")
+          if (feedback.trim()) {
+            deps.workflowController.respondToCheckpoint(intent.runId, { action: "revise", feedback })
+          } else {
+            deps.workflowController.respondToCheckpoint(intent.runId, { action: "abort" })
+          }
+        }
+        break
+      }
+    }
+  }
+}
+
+function openPanelOnce(
+  deps: FleetPanelDeps,
+  host: WorkflowPanelHostContext,
+): Promise<WorkflowPanelIntent | null> {
+  return new Promise((resolve) => {
+    let resolved = false
+    const safeResolve = (intent: WorkflowPanelIntent | null) => {
+      if (resolved) return
+      resolved = true
+      resolve(intent)
+    }
+    host.custom((_tui, theme, _kb, done) => {
+      const panel = new FleetPanel({
+        theme,
+        deps,
+        onDone: (intent?: WorkflowPanelIntent | null) => {
+          safeResolve(intent ?? null)
+          done()
+        },
+        onNotify: (m: string, t?: "info" | "warning" | "error") => host.notify(m, t),
+      })
+      return panel
+    })
+  })
+}

package/src/workflows/registry.ts

@@ -0,0 +1,68 @@
+// SPEC-6-3 §3.7 — saved-workflow discovery. Project > global > builtin (later scopes win by name).
+// A workflow .js exports `meta` { name, description, phases? } + a script body. We parse the
+// source via the canonical balanced-brace parser (source.ts) which produces the meta, the
+// stripped body, and a normalized `executable` string the vm realm can compile as CommonJS.
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { parseWorkflowSource } from "./source.ts";
+
+export type WorkflowSource = "builtin" | "global" | "project";
+
+export interface WorkflowDef {
+  name: string;
+  description: string;
+  phases: { title: string }[];
+  sourceText: string;   // the original file content
+  body: string;         // script body after the meta declaration is removed
+  executable: string;    // normalized CommonJS executable (passed to the runner)
+  source: WorkflowSource;
+  filePath: string;
+}
+
+export interface DiscoverOpts { projectDir: string; globalDir: string; builtinDir: string; }
+
+export interface DiscoverResult {
+  workflows: Map<string, WorkflowDef>;
+  errors: string[];
+  warnings: string[];
+}
+
+function loadDir(dir: string, source: WorkflowSource, into: Map<string, WorkflowDef>, errors: string[]): void {
+  if (!existsSync(dir)) return;
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith(".js")) continue;
+    const filePath = join(dir, f);
+    const content = readFileSync(filePath, "utf8");
+    try {
+      const parsed = parseWorkflowSource(content, { filePath, requireMeta: true });
+      if (!parsed.meta) { errors.push(`${filePath}: missing \`export const meta = {…}\``); continue; }
+      const { name, description, phases } = parsed.meta;
+      into.set(name, { name, description, phases, sourceText: parsed.source, body: parsed.body, executable: parsed.executable, source, filePath });
+    } catch (e) {
+      errors.push((e as Error).message);
+    }
+  }
+}
+
+/** Discover workflows from three scopes. Later scopes win by name (project > global > builtin). */
+export function discoverWorkflows(opts: DiscoverOpts): DiscoverResult {
+  const map = new Map<string, WorkflowDef>();
+  const errors: string[] = [];
+  loadDir(opts.builtinDir, "builtin", map, errors);
+  loadDir(opts.globalDir, "global", map, errors);
+  loadDir(opts.projectDir, "project", map, errors); // project shadows (set last wins)
+  return { workflows: map, errors, warnings: [] };
+}
+
+export class WorkflowRegistry {
+  private readonly byName = new Map<string, WorkflowDef>();
+  constructor(workflows: Map<string, WorkflowDef>) { for (const [k, v] of workflows) this.byName.set(k, v); }
+  get(name: string): WorkflowDef | undefined { return this.byName.get(name); }
+  list(): WorkflowDef[] { return [...this.byName.values()]; }
+
+  /** SPEC-6-3 §6: clear + repopulate the existing map (live reference preserved for all consumers). */
+  replace(workflows: WorkflowDef[]): void {
+    this.byName.clear();
+    for (const w of workflows) this.byName.set(w.name, w);
+  }
+}