@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/tui.ts

@@ -1,182 +0,0 @@
-/**
- * TUI progress widget for workflow execution.
- * Shows step status, timing, cost, and parallel execution indicators.
- */
-import type { Theme } from "@mariozechner/pi-coding-agent";
-import type { TUI, Component } from "@mariozechner/pi-tui";
-import type { WorkflowSpec, ExecutionState, StepResult } from "./types.ts";
-import { formatDuration, formatCost, formatTokens } from "./format.ts";
-
-export interface StepActivity {
-  tool: string;      // "read", "edit", "bash", etc.
-  preview: string;   // "src/index.ts", "npm test", etc.
-  timestamp: number;
-}
-
-export interface StepOutputSummary {
-  tasks?: Array<{ name: string; status: string; files?: string[] }>;
-  testCount?: number;
-  note?: string;
-}
-
-export interface ProgressWidgetState {
-  spec: WorkflowSpec;
-  state: ExecutionState;
-  currentStep?: string;          // name of the currently running step (comma-separated for parallel)
-  startTime: number;             // Date.now() when workflow started
-  parallelSubSteps?: Record<string, import("./types.ts").StepResult>;  // live sub-step results for parallel step
-  resumedSteps?: number;         // number of steps carried from a prior run (resume indicator)
-  activities: Map<string, StepActivity[]>;  // stepName → recent tool calls (ring buffer, last 5)
-  outputSummaries: Map<string, StepOutputSummary>; // stepName → parsed output after completion
-}
-
-/**
- * Create a widget factory for ctx.ui.setWidget().
- * Returns a function that pi calls to get the component.
- *
- * The returned component renders a compact progress view:
- *   ─────────────────────────────────────
- *   ● bugfix  step 2/3              1m32s
- *     ✓ diagnose     42s   $0.03  12k tok
- *     ▸ fix           50s   8k tok...
- *     · verify
- *   ─────────────────────────────────────
- */
-export function createProgressWidget(
-  widgetState: ProgressWidgetState,
-): (tui: TUI, theme: Theme) => Component & { dispose?(): void } {
-  return (tui: TUI, theme: Theme) => {
-    /** Pulse interval (ms) for the elapsed-time ticker. Balances update frequency vs overhead. */
-    const PULSE_INTERVAL_MS = 800;
-    let pulseOn = true;
-    const interval = setInterval(() => {
-      pulseOn = !pulseOn;
-      tui.requestRender();
-    }, PULSE_INTERVAL_MS);
-
-    return {
-      render(width: number): string[] {
-        const lines: string[] = [];
-        const stepNames = Object.keys(widgetState.spec.steps);
-        const totalSteps = stepNames.length;
-
-        // Parse current steps (may be comma-separated for parallel)
-        const currentSteps = widgetState.currentStep?.split(", ") ?? [];
-        const parallelCount = currentSteps.length;
-
-        // Determine current step number
-        let currentStepNum = 0;
-        if (currentSteps.length > 0 && currentSteps[0]) {
-          const idx = stepNames.indexOf(currentSteps[0]);
-          currentStepNum = idx >= 0 ? idx + 1 : 0;
-        } else {
-          // Count completed steps
-          currentStepNum = Object.values(widgetState.state.steps).filter(
-            (s) => s.status === "completed",
-          ).length;
-        }
-
-        const elapsed = formatDuration(Date.now() - widgetState.startTime);
-        const workflowName = theme.bold(widgetState.spec.name);
-        const indicator = pulseOn
-          ? theme.fg("accent", "\u25cf")
-          : theme.fg("dim", "\u25cf");
-
-        const parallelTag = parallelCount > 1 ? ` [${parallelCount} parallel]` : "";
-        const headerLine = `${indicator} ${workflowName}  step ${currentStepNum}/${totalSteps}${parallelTag}  ${theme.fg("dim", elapsed)}`;
-        lines.push(headerLine.length > width ? headerLine.slice(0, width) : headerLine);
-
-        // Resumed indicator
-        if (widgetState.resumedSteps) {
-          const resumedLine = `  ${theme.fg("dim", "\u21bb")} Resumed: ${widgetState.resumedSteps} steps from prior run`;
-          lines.push(resumedLine.length > width ? resumedLine.slice(0, width) : resumedLine);
-        }
-
-        // Paused indicator
-        if (widgetState.state.status === "paused") {
-          const pausedLine = `  ${theme.fg("accent", "\u23f8")} Paused`;
-          lines.push(pausedLine.length > width ? pausedLine.slice(0, width) : pausedLine);
-        }
-
-        // Step lines
-        for (const stepName of stepNames) {
-          const stepResult: StepResult | undefined = widgetState.state.steps[stepName];
-          let line: string;
-
-          if (stepResult && stepResult.status === "skipped") {
-            // Skipped step: ⊘ stepName [skipped]
-            line = `  ${theme.fg("dim", "\u2298")} ${stepName} ${theme.fg("dim", "[skipped]")}`;
-          } else if (stepResult && stepResult.status === "completed") {
-            const dur = formatDuration(stepResult.durationMs);
-            const cost = formatCost(stepResult.usage.cost);
-            const tok = formatTokens(stepResult.usage.input + stepResult.usage.output);
-            // Show step type indicator for gate/transform
-            const typeTag = stepResult.agent === "gate" ? " [gate]" : stepResult.agent === "transform" ? " [transform]" : "";
-            const truncTag = stepResult.truncated ? ` ${theme.fg("warning", "[truncated]")}` : "";
-            line = `  ${theme.fg("success", "\u2713")} ${stepName}${typeTag}  ${theme.fg("dim", dur)}  ${theme.fg("dim", cost)}  ${theme.fg("dim", tok)}${truncTag}`;
-            lines.push(line.length > width ? line.slice(0, width) : line);
-
-            // Render output summary sub-lines (capped at 3)
-            const summary = widgetState.outputSummaries?.get(stepName);
-            if (summary) {
-              let summaryLines = 0;
-              const MAX_SUMMARY_LINES = 3;
-              if (summary.tasks) {
-                for (const task of summary.tasks) {
-                  if (summaryLines >= MAX_SUMMARY_LINES) break;
-                  const files = task.files?.join(", ") || "";
-                  const statusIcon = task.status === "done" ? "\u2713" : task.status === "failed" ? "\u2717" : "\u00b7";
-                  const taskLine = `      ${theme.fg("dim", statusIcon)} ${theme.fg("dim", task.name)}${files ? "  " + theme.fg("dim", files) : ""}`;
-                  lines.push(taskLine.length > width ? taskLine.slice(0, width) : taskLine);
-                  summaryLines++;
-                }
-              }
-              if (summary.testCount && summaryLines < MAX_SUMMARY_LINES) {
-                const testLine = `      ${theme.fg("dim", `${summary.testCount} tests pass`)}`;
-                lines.push(testLine.length > width ? testLine.slice(0, width) : testLine);
-                summaryLines++;
-              }
-              if (summary.note && summaryLines < MAX_SUMMARY_LINES) {
-                const noteLine = `      ${theme.fg("dim", summary.note)}`;
-                lines.push(noteLine.length > width ? noteLine.slice(0, width) : noteLine);
-              }
-            }
-            continue;  // skip the push below, already pushed
-          } else if (stepResult && stepResult.status === "failed") {
-            const dur = formatDuration(stepResult.durationMs);
-            const errorPreview = stepResult.error || "Unknown error";
-            line = `  ${theme.fg("error", "\u2717")} ${stepName}  ${theme.fg("dim", dur)}  ${errorPreview}`;
-          } else if (stepResult && stepResult.agent === "parallel") {
-            // Completed parallel step — show with sub-step count
-            const dur = formatDuration(stepResult.durationMs);
-            const cost = formatCost(stepResult.usage.cost);
-            const tok = formatTokens(stepResult.usage.input + stepResult.usage.output);
-            line = `  ${theme.fg("success", "\u2713")} ${stepName} [parallel]  ${theme.fg("dim", dur)}  ${theme.fg("dim", cost)}  ${theme.fg("dim", tok)}`;
-          } else if (currentSteps.includes(stepName)) {
-            const stepElapsed = formatDuration(Date.now() - widgetState.startTime);
-            line = `  ${theme.fg("accent", "\u25b8")} ${theme.fg("accent", stepName)}  ${theme.fg("dim", stepElapsed + "...")}`;
-            lines.push(line.length > width ? line.slice(0, width) : line);
-
-            // Render most recent tool activity under running step
-            const activities = widgetState.activities?.get(stepName);
-            if (activities && activities.length > 0) {
-              const latest = activities[activities.length - 1];
-              const actLine = `      ${theme.fg("dim", latest.tool)} ${theme.fg("dim", latest.preview)}`;
-              lines.push(actLine.length > width ? actLine.slice(0, width) : actLine);
-            }
-            continue;  // skip the push below, already pushed
-          } else {
-            line = `  ${theme.fg("dim", "\u00b7")} ${stepName}`;
-          }
-
-          lines.push(line.length > width ? line.slice(0, width) : line);
-        }
-
-        return lines;
-      },
-      dispose() {
-        clearInterval(interval);
-      },
-    };
-  };
-}

package/src/types.ts

@@ -1,195 +0,0 @@
-// ── Workflow Spec (parsed from YAML) ──
-
-export interface WorkflowSpec {
-  name: string;
-  description: string;
-  version?: string;
-  input?: Record<string, unknown>;       // JSON Schema object
-  output?: Record<string, unknown>;      // JSON Schema object
-  triggerTurn?: boolean;                  // default: true
-  completion?: CompletionSpec;           // controls post-completion message to main LLM
-  steps: Record<string, StepSpec>;       // ordered (YAML preserves insertion order)
-  artifacts?: Record<string, ArtifactSpec>; // persistent files written after workflow completion
-  // Set by discovery, not by YAML:
-  source: "user" | "project";
-  filePath: string;
-}
-
-export interface ArtifactSpec {
-  path: string;                          // destination path, may contain ${{ }} expressions
-  from: string;                          // ${{ }} expression for the data source
-  schema?: string;                       // optional JSON Schema to validate before writing
-}
-
-export interface RetryConfig {
-  maxAttempts?: number;                  // default 1 (no retry). Total attempts, not retries.
-  onExhausted?: 'fail' | 'skip';        // default 'fail'
-  steeringMessage?: string;             // optional custom steering text for retries (agent steps only)
-}
-
-export interface StepSpec {
-  agent?: string;                        // optional — not needed for gate/transform steps
-  model?: string;                        // model override
-  input?: Record<string, unknown>;       // values may contain ${{ }} expressions
-  output?: StepOutputSpec;
-  when?: string;                         // ${{ }} expression, evaluated as truthy/falsy
-  timeout?: { seconds: number };
-  retry?: RetryConfig;                   // per-step retry config
-  loop?: LoopSpec;
-  gate?: GateSpec;
-  transform?: TransformSpec;
-  parallel?: Record<string, StepSpec>;   // named sub-steps to run concurrently
-  pause?: string | boolean;              // pause step — string is message to display, true = pause with no message
-  command?: string;                      // shell command to run (captures stdout as output)
-  forEach?: string;                      // ${{ }} expression resolving to an array
-  as?: string;                           // variable name to bind each element (default: "item")
-  workflow?: string;                     // phase 6 — not yet supported
-}
-// Note: exactly one of agent, gate, transform, loop, or parallel must be set.
-// workflow is phase 6.
-
-export interface LoopSpec {
-  maxAttempts: number;                   // max iterations (required)
-  attempts?: string;                     // ${{ }} expression overriding maxAttempts at runtime
-  steps: Record<string, StepSpec>;       // steps to execute each iteration
-  onExhausted?: StepSpec;               // step to run if all attempts fail
-}
-
-export interface GateSpec {
-  check: string;                         // shell command to run
-  onPass?: "continue" | "break";         // default: "continue" (proceed to next step)
-  onFail?: "continue" | "break" | "fail"; // default: "fail" (stop the workflow)
-}
-
-export interface TransformSpec {
-  /**
-   * A mapping of output field names to ${{ }} expressions.
-   * The result is an object with each field resolved.
-   * No LLM invocation — pure data transformation.
-   */
-  mapping: Record<string, unknown>;
-}
-
-export interface StepOutputSpec {
-  format?: "json" | "text";              // default: "text"
-  schema?: string;                       // path to JSON Schema file, relative to workflow spec
-  path?: string;                         // output file path — may contain ${{ }} expressions
-}
-
-// ── Agent Spec (loaded from .md frontmatter or .agent.yaml) ──
-
-export interface AgentSpec {
-  name: string;
-  description?: string;
-  role?: string;                         // sensor | reasoning | action | quality
-  systemPrompt?: string;                 // compiled system prompt (from template rendering)
-  promptTemplate?: string;               // system prompt template path
-  taskTemplate?: string;                 // task prompt template path
-  model?: string;
-  thinking?: string;
-  tools?: string[];
-  extensions?: string[];
-  skills?: string[];
-  output?: string;                       // output file path
-  inputSchema?: Record<string, unknown>; // JSON Schema for input
-  outputFormat?: "json" | "text";        // what the agent produces
-  outputSchema?: string;                 // path to output JSON Schema
-}
-
-// ── Execution State ──
-
-export interface ExecutionState {
-  input: unknown;
-  steps: Record<string, StepResult>;
-  status: "running" | "completed" | "failed" | "paused";
-  loop?: LoopState;                      // set when inside a loop
-  // Resume support:
-  workflowName?: string;       // which workflow this run belongs to
-  specVersion?: string;        // workflow spec version at time of run
-  startedAt?: string;          // ISO timestamp of run start
-  updatedAt?: string;          // ISO timestamp of last state write
-}
-
-export interface LoopState {
-  stepName: string;                      // name of the loop step
-  iteration: number;                     // current iteration (0-based)
-  maxAttempts: number;
-  priorAttempts: LoopAttempt[];          // results from previous iterations
-}
-
-export interface LoopAttempt {
-  iteration: number;
-  steps: Record<string, StepResult>;     // results of all steps in this iteration
-}
-
-export interface StepResult {
-  step: string;
-  agent: string;
-  status: "completed" | "failed" | "skipped";
-  output?: unknown;                      // parsed structured output (if schema-bound)
-  textOutput?: string;                   // raw text from last assistant message
-  outputPath?: string;                   // absolute path to persisted output JSON
-  sessionLog?: string;                   // path to session log file
-  usage: StepUsage;
-  durationMs: number;
-  error?: string;                        // error message if failed
-  truncated?: boolean;                   // true if stdout exceeded MAX_STDOUT_BYTES and data was lost
-  warnings?: string[];                   // non-fatal issues encountered during step execution
-  attempt?: number;                      // which attempt this result is from (1-based)
-  totalAttempts?: number;                // total attempts made
-  priorErrors?: string[];                // error messages from prior failed attempts
-}
-
-export interface StepUsage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  cost: number;
-  turns: number;
-}
-
-// ── Workflow Result (returned to caller) ──
-
-export interface WorkflowResult {
-  workflow: string;
-  runId: string;
-  status: "completed" | "failed" | "paused";
-  steps: Record<string, StepResult>;
-  output?: unknown;                      // final workflow output (last step's output, or explicit)
-  totalUsage: StepUsage;
-  totalDurationMs: number;
-  runDir: string;                        // absolute path to .workflows/runs/<name>/runs/<run-id>/
-  artifacts?: Record<string, string>;    // name → absolute path of written artifact files
-}
-
-// ── Completion Spec ──
-
-export interface CompletionSpec {
-  message?: string;                      // LLM instruction text (may contain ${{ }} expressions)
-  include?: string[];                    // expression paths to resolve and attach as data
-  template?: string;                     // full template with ${{ }} (mutually exclusive with message)
-}
-
-// ── Expression Scope (what ${{ }} expressions resolve against) ──
-
-export interface ExpressionScope {
-  input: unknown;
-  steps: Record<string, StepResult>;
-  [key: string]: unknown;  // allows use as Record<string, unknown>
-}
-
-// ── Completion Scope (wider scope for completion templates) ──
-
-export interface CompletionScope {
-  input: unknown;
-  steps: Record<string, StepResult>;
-  totalUsage: StepUsage;
-  totalDurationMs: number;
-  runDir: string;
-  runId: string;
-  workflow: string;
-  status: "completed" | "failed";
-  output?: unknown;
-  [key: string]: unknown;  // allows use as Record<string, unknown>
-}

package/src/verifier-schema.test.ts

@@ -1,226 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import path from "node:path";
-import { validateFromFile } from "@davidorex/pi-project/src/schema-validator.ts";
-
-const schemaPath = path.resolve(import.meta.dirname, "..", "schemas", "verifier-output.schema.json");
-
-function validVerifierOutput() {
-  return {
-    status: "passed",
-    score: "3/3",
-    truths: [
-      { truth: "Tests pass", status: "verified", evidence: "npm test exited 0" },
-      { truth: "File exists", status: "verified", evidence: "ls confirmed" },
-      { truth: "Schema valid", status: "verified", evidence: "ajv validates" },
-    ],
-    criteria_results: [
-      {
-        criterion: "All tests pass",
-        verify_method: "command",
-        status: "passed",
-        expected_outcome: "exit code 0",
-        actual_outcome: "exit code 0",
-        evidence: "npm test output: 3 passing",
-      },
-      {
-        criterion: "File structure correct",
-        verify_method: "inspect",
-        status: "passed",
-        evidence: "All expected files present",
-      },
-      {
-        criterion: "UI renders correctly",
-        verify_method: "inspect",
-        status: "skipped",
-        evidence: "Requires visual inspection",
-      },
-    ],
-  };
-}
-
-describe("verifier-output schema validation", () => {
-  it("validates a complete verifier output", () => {
-    const data = validVerifierOutput();
-    const result = validateFromFile(schemaPath, data, "test");
-    assert.deepStrictEqual(result, data);
-  });
-
-  it("validates with all optional fields present", () => {
-    const data = {
-      ...validVerifierOutput(),
-      artifacts: [
-        { path: "src/index.ts", status: "verified", exists: true, substantive: true, wired: true, details: "Main entry point" },
-        { path: "src/missing.ts", status: "missing", exists: false },
-      ],
-      requirements_coverage: [
-        { requirement_id: "REQ-001", status: "satisfied", supporting_truths: ["Tests pass"] },
-        { requirement_id: "REQ-002", status: "needs_human" },
-      ],
-      human_verification: [
-        { name: "UI layout", test: "Open browser and check layout", expected: "Grid renders correctly", why_human: "Requires visual inspection" },
-      ],
-      gaps: [
-        { truth: "Performance benchmark", status: "failed", reason: "No benchmark data available" },
-      ],
-    };
-    const result = validateFromFile(schemaPath, data, "test");
-    assert.ok(result);
-  });
-
-  it("validates with empty optional arrays", () => {
-    const data = {
-      ...validVerifierOutput(),
-      artifacts: [],
-      requirements_coverage: [],
-      human_verification: [],
-      gaps: [],
-    };
-    const result = validateFromFile(schemaPath, data, "test");
-    assert.ok(result);
-  });
-
-  it("rejects missing required field: status", () => {
-    const data = validVerifierOutput();
-    delete (data as any).status;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects missing required field: score", () => {
-    const data = validVerifierOutput();
-    delete (data as any).score;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects missing required field: truths", () => {
-    const data = validVerifierOutput();
-    delete (data as any).truths;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects missing required field: criteria_results", () => {
-    const data = validVerifierOutput();
-    delete (data as any).criteria_results;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects invalid status enum value", () => {
-    const data = validVerifierOutput();
-    data.status = "invalid_status" as any;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects invalid truth status enum value", () => {
-    const data = validVerifierOutput();
-    data.truths[0].status = "bad_status" as any;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects invalid verify_method enum value", () => {
-    const data = validVerifierOutput();
-    data.criteria_results[0].verify_method = "magic" as any;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects invalid criteria_results status enum value", () => {
-    const data = validVerifierOutput();
-    data.criteria_results[0].status = "invalid" as any;
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-
-  it("rejects invalid artifact status enum value", () => {
-    const data = {
-      ...validVerifierOutput(),
-      artifacts: [{ path: "test.ts", status: "unknown" }],
-    };
-    assert.throws(
-      () => validateFromFile(schemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-});
-
-describe("plan-breakdown schema validation", () => {
-  const planSchemaPath = path.resolve(import.meta.dirname, "..", "schemas", "plan-breakdown.schema.json");
-
-  it("validates a valid plan breakdown", () => {
-    const data = {
-      plans: [
-        {
-          name: "implement-auth",
-          intent: "Add authentication",
-          tasks: ["Create auth module", "Add login endpoint"],
-          acceptance_criteria: ["Login works", "Tests pass"],
-          files_to_change: ["src/auth.ts"],
-          context_needed: ["existing user model"],
-          parallel_group: "core",
-        },
-      ],
-    };
-    const result = validateFromFile(planSchemaPath, data, "test");
-    assert.ok(result);
-  });
-
-  it("rejects missing required plan fields", () => {
-    const data = { plans: [{ name: "test" }] };
-    assert.throws(
-      () => validateFromFile(planSchemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-});
-
-describe("execution-results schema validation", () => {
-  const execSchemaPath = path.resolve(import.meta.dirname, "..", "schemas", "execution-results.schema.json");
-
-  it("validates a valid execution result", () => {
-    const data = {
-      status: "complete",
-      tasks: [
-        { name: "implement feature", status: "done", files_modified: ["src/index.ts"], commit_hash: "abc123", notes: "Done" },
-      ],
-      decisions: [
-        { id: "D-001", decision: "Use ESM", rationale: "Modern standard", status: "decided" },
-      ],
-      issues: [
-        { severity: "info", description: "Minor lint warning" },
-      ],
-      test_count: 42,
-      commit_hash: "abc123",
-    };
-    const result = validateFromFile(execSchemaPath, data, "test");
-    assert.ok(result);
-  });
-
-  it("rejects invalid status enum", () => {
-    const data = { status: "unknown", tasks: [] };
-    assert.throws(
-      () => validateFromFile(execSchemaPath, data, "test"),
-      (err: any) => err.message.includes("Validation failed"),
-    );
-  });
-});