pi-cicd 0.3.0 → 1.0.1

package/src/headless/orchestrator.ts

@@ -0,0 +1,207 @@
+/**
+ * pi-ci — Headless orchestrator.
+ *
+ * Ties together exit codes, answer injection, idle detection, and JSONL
+ * streaming into a single execution loop.
+ */
+
+import type { ExitCode, CIEvent, CIOptions } from "../types.ts";
+import { EXIT_CODES } from "../types.ts";
+import { resolveExitCode } from "./exit-codes.ts";
+import { matchAnswer } from "./answer-injector.ts";
+import type { AnswerEntry } from "../types.ts";
+import { IdleDetector } from "./idle-detector.ts";
+import { CIEventCollector, writeCIEvent } from "./jsonl-stream.ts";
+import type { Writable } from "node:stream";
+
+export interface OrchestratorResult {
+  exitCode: ExitCode;
+  events: CIEvent[];
+  durationMs: number;
+}
+
+export interface OrchestratorHooks {
+  /** Called for each step of execution. Return a status string to signal completion. */
+  executeStep: (
+    prompt: string,
+    injectAnswer: (question: string) => string | undefined,
+  ) => Promise<StepResult>;
+  /** Optional writable for JSONL streaming. */
+  outputStream?: Writable;
+}
+
+export interface StepResult {
+  status: string;
+  edits?: { file: string; lines_added: number; lines_removed: number }[];
+  tests?: { command: string; passed: number; failed: number }[];
+  cost?: { tokens: { input: number; output: number }; cost_usd: number };
+}
+
+const RESTART_CONFIG = {
+  baseDelayMs: 5_000,
+  maxDelayMs: 30_000,
+  backoffMultiplier: 2,
+};
+
+export class HeadlessOrchestrator {
+  private readonly collector = new CIEventCollector();
+  private readonly answers: AnswerEntry[];
+  private readonly idleTimeoutMs: number;
+  private readonly maxRetries: number;
+  private readonly hooks: OrchestratorHooks;
+
+  constructor(
+    answers: AnswerEntry[],
+    options: CIOptions,
+    hooks: OrchestratorHooks,
+  ) {
+    this.answers = answers;
+    this.idleTimeoutMs = options.idleTimeoutMs ?? 15_000;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.hooks = hooks;
+  }
+
+  /**
+   * Run the orchestrator loop.
+   *
+   * 1. Emit ci_start
+   * 2. Execute steps via the hook, checking for answer injection
+   * 3. On idle timeout → retry with exponential backoff
+   * 4. Emit ci_end with the resolved exit code
+   */
+  async run(prompt: string, mode: "single" | "plan"): Promise<OrchestratorResult> {
+    const startTime = Date.now();
+
+    const startEvent: CIEvent = {
+      type: "ci_start",
+      timestamp: new Date().toISOString(),
+      task: prompt,
+      mode,
+    };
+    this.emit(startEvent);
+
+    let lastExitCode: ExitCode = EXIT_CODES.ERROR;
+    let retries = 0;
+
+    while (retries <= this.maxRetries) {
+      const result = await this.runAttempt(prompt);
+      lastExitCode = result;
+
+      if (lastExitCode === EXIT_CODES.SUCCESS) break;
+      if (lastExitCode === EXIT_CODES.BLOCKED || lastExitCode === EXIT_CODES.CANCELLED) break;
+
+      // Retry on error/timeout
+      retries++;
+      if (retries <= this.maxRetries) {
+        const delay = Math.min(
+          RESTART_CONFIG.baseDelayMs *
+            Math.pow(RESTART_CONFIG.backoffMultiplier, retries - 1),
+          RESTART_CONFIG.maxDelayMs,
+        );
+        await sleep(delay);
+      }
+    }
+
+    const durationMs = Date.now() - startTime;
+    const endEvent: CIEvent = {
+      type: "ci_end",
+      timestamp: new Date().toISOString(),
+      exit_code: lastExitCode,
+      duration_ms: durationMs,
+    };
+    this.emit(endEvent);
+
+    return {
+      exitCode: lastExitCode,
+      events: this.collector.all(),
+      durationMs,
+    };
+  }
+
+  /**
+   * Single attempt: run with idle detection.
+   */
+  private async runAttempt(prompt: string): Promise<ExitCode> {
+    return new Promise<ExitCode>((resolve) => {
+      let settled = false;
+
+      const idle = new IdleDetector({
+        idleTimeoutMs: this.idleTimeoutMs,
+        onTimeout: () => {
+          if (!settled) {
+            settled = true;
+            resolve(EXIT_CODES.TIMEOUT);
+          }
+        },
+      });
+
+      const injectAnswer = (question: string): string | undefined => {
+        idle.reset();
+        return matchAnswer(this.answers, question);
+      };
+
+      idle.start();
+
+      this.hooks
+        .executeStep(prompt, injectAnswer)
+        .then((stepResult) => {
+          if (!settled) {
+            settled = true;
+            idle.stop();
+
+            // Emit detail events
+            if (stepResult.edits) {
+              for (const edit of stepResult.edits) {
+                this.emit({
+                  type: "ci_edit",
+                  timestamp: new Date().toISOString(),
+                  file: edit.file,
+                  lines_added: edit.lines_added,
+                  lines_removed: edit.lines_removed,
+                });
+              }
+            }
+            if (stepResult.tests) {
+              for (const t of stepResult.tests) {
+                this.emit({
+                  type: "ci_test",
+                  timestamp: new Date().toISOString(),
+                  command: t.command,
+                  passed: t.passed,
+                  failed: t.failed,
+                });
+              }
+            }
+            if (stepResult.cost) {
+              this.emit({
+                type: "ci_cost",
+                timestamp: new Date().toISOString(),
+                tokens: stepResult.cost.tokens,
+                cost_usd: stepResult.cost.cost_usd,
+              });
+            }
+
+            resolve(resolveExitCode(stepResult.status));
+          }
+        })
+        .catch(() => {
+          if (!settled) {
+            settled = true;
+            idle.stop();
+            resolve(EXIT_CODES.ERROR);
+          }
+        });
+    });
+  }
+
+  private emit(event: CIEvent): void {
+    this.collector.emit(event);
+    if (this.hooks.outputStream) {
+      writeCIEvent(this.hooks.outputStream, event);
+    }
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}

package/{dist/index.js → src/index.ts}

@@ -3,7 +3,19 @@
  *
  * Registers the /ci status command and CI lifecycle hooks.
  */
-import { ciStatusHandler, } from "./src/tools/ci_status.ts";
+
+import type { CIEvent, CIOptions, ExitCode } from "./src/types.ts";
+import { EXIT_CODES } from "./src/types.ts";
+import {
+  ciStatusHandler,
+  createRunTracker,
+  clearRuns,
+  registerRun,
+  type CIRunRecord,
+} from "./src/tools/ci_status.ts";
+import { CIPipeline, type PipelineResult } from "./src/ci/pipeline.ts";
+import { generateReport } from "./src/ci/report.ts";
+
 // Re-export for consumers
 export { EXIT_CODES } from "./src/types.ts";
 export { resolveExitCode } from "./src/headless/exit-codes.ts";
@@ -17,15 +29,24 @@ export { parseTestResults } from "./src/ci/test-runner.ts";
 export { generateReport } from "./src/ci/report.ts";
 export { ciStatusHandler, registerRun, clearRuns, createRunTracker } from "./src/tools/ci_status.ts";
 export { loadCiConfig, DEFAULT_CONFIG } from "./src/config.ts";
+export type { PiCiConfig } from "./src/config.ts";
+
+/**
+ * Extension API type (minimal — avoids hard dep on pi-coding-agent types).
+ */
+interface ExtensionAPI {
+  registerCommand?: (name: string, handler: (args: unknown) => string | Promise<string>) => void;
+  on?: (event: string, handler: (...args: unknown[]) => void) => void;
+}
+
 /**
  * Default export — Pi extension registration.
  */
-export default function piCiExtension(pi) {
-    // Register /ci status command
-    if (pi.registerCommand) {
-        pi.registerCommand("ci", (args) => {
-            return ciStatusHandler(args);
-        });
-    }
+export default function piCiExtension(pi: ExtensionAPI): void {
+  // Register /ci status command
+  if (pi.registerCommand) {
+    pi.registerCommand("ci", (args: unknown) => {
+      return ciStatusHandler(args);
+    });
+  }
 }
-//# sourceMappingURL=index.js.map

package/src/tools/ci_status.ts

@@ -0,0 +1,137 @@
+/**
+ * pi-ci — /ci status command handler.
+ *
+ * Shows the status of the current or last CI run.
+ */
+
+import { CIEventCollector } from "../headless/jsonl-stream.ts";
+import { generateReport } from "../ci/report.ts";
+import type { CIEvent, CIEndEvent, ExitCode } from "../types.ts";
+import { isCIEndEvent } from "../headless/jsonl-stream.ts";
+
+export interface CIRunRecord {
+  id: string;
+  startTime: string;
+  events: CIEvent[];
+  exitCode?: ExitCode;
+  durationMs?: number;
+}
+
+/**
+ * Simple in-memory registry of CI runs (for the status command).
+ */
+const runRegistry = new Map<string, CIRunRecord>();
+
+/**
+ * Register a CI run for status lookups.
+ */
+export function registerRun(record: CIRunRecord): void {
+  runRegistry.set(record.id, record);
+}
+
+/**
+ * Clear all registered runs (useful for testing).
+ */
+export function clearRuns(): void {
+  runRegistry.clear();
+}
+
+/**
+ * Get a specific run by ID (prefix match supported).
+ */
+export function getRun(id: string): CIRunRecord | undefined {
+  // Exact match first
+  if (runRegistry.has(id)) {
+    return runRegistry.get(id);
+  }
+  // Prefix match
+  for (const [key, value] of runRegistry) {
+    if (key.startsWith(id)) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Handle the /ci status command.
+ *
+ * Returns a human-readable status string.
+ */
+export function ciStatusHandler(args: unknown): string {
+  const runId = typeof args === "string" ? args : undefined;
+
+  if (runId) {
+    const run = getRun(runId);
+    if (!run) {
+      return `No CI run found matching: ${runId}`;
+    }
+    return formatRunStatus(run);
+  }
+
+  // Show all runs
+  if (runRegistry.size === 0) {
+    return "No CI runs found.";
+  }
+
+  const lines: string[] = [];
+  for (const run of runRegistry.values()) {
+    lines.push(formatRunStatus(run));
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+function formatRunStatus(run: CIRunRecord): string {
+  const lines: string[] = [];
+  lines.push(`Run:       ${run.id}`);
+  lines.push(`Started:   ${run.startTime}`);
+
+  const endEvent = run.events.find((e): e is CIEndEvent => isCIEndEvent(e));
+  if (endEvent) {
+    lines.push(`Exit Code: ${endEvent.exit_code}`);
+    lines.push(`Duration:  ${(endEvent.duration_ms / 1000).toFixed(1)}s`);
+
+    const status =
+      endEvent.exit_code === 0
+        ? "SUCCESS"
+        : endEvent.exit_code === 10
+          ? "BLOCKED"
+          : endEvent.exit_code === 11
+            ? "CANCELLED"
+            : "ERROR";
+    lines.push(`Status:    ${status}`);
+  } else {
+    lines.push("Status:    RUNNING");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Create a CI run tracker that collects events and registers the run.
+ */
+export function createRunTracker(runId: string): {
+  collector: CIEventCollector;
+  finalize: () => CIRunRecord;
+} {
+  const collector = new CIEventCollector();
+  const startTime = new Date().toISOString();
+
+  return {
+    collector,
+    finalize() {
+      const events = collector.all();
+      const endEvent = events.find((e): e is CIEndEvent => isCIEndEvent(e));
+      const record: CIRunRecord = {
+        id: runId,
+        startTime,
+        events,
+        exitCode: endEvent?.exit_code,
+        durationMs: endEvent?.duration_ms,
+      };
+      registerRun(record);
+      return record;
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,149 @@
+/**
+ * pi-ci — Shared types for headless CI mode.
+ *
+ * Exit code contract and CI event types per SPEC.md §2.1 and §5.
+ */
+
+// ---------------------------------------------------------------------------
+// Exit codes
+// ---------------------------------------------------------------------------
+
+export const EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  TIMEOUT: 1,
+  BLOCKED: 10,
+  CANCELLED: 11,
+  NEEDS_INPUT: 12,
+} as const;
+
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
+
+// ---------------------------------------------------------------------------
+// CI events (JSONL stream)
+// ---------------------------------------------------------------------------
+
+export type CIEventType =
+  | "ci_start"
+  | "ci_progress"
+  | "ci_edit"
+  | "ci_test"
+  | "ci_cost"
+  | "ci_end";
+
+export interface CIEventBase {
+  type: CIEventType;
+  timestamp: string; // ISO 8601
+}
+
+export interface CIStartEvent extends CIEventBase {
+  type: "ci_start";
+  task: string;
+  mode: "single" | "plan";
+}
+
+export type CIRunPhase =
+  | "exploring"
+  | "planning"
+  | "implementing"
+  | "verifying"
+  | "reviewing";
+
+export interface CIProgressEvent extends CIEventBase {
+  type: "ci_progress";
+  phase: CIRunPhase;
+  files?: string[];
+}
+
+export interface CIEditEvent extends CIEventBase {
+  type: "ci_edit";
+  file: string;
+  lines_added: number;
+  lines_removed: number;
+}
+
+export interface CITestEvent extends CIEventBase {
+  type: "ci_test";
+  command: string;
+  passed: number;
+  failed: number;
+}
+
+export interface CICostEvent extends CIEventBase {
+  type: "ci_cost";
+  tokens: { input: number; output: number };
+  cost_usd: number;
+}
+
+export interface CIEndEvent extends CIEventBase {
+  type: "ci_end";
+  exit_code: ExitCode;
+  duration_ms: number;
+}
+
+export type CIEvent =
+  | CIStartEvent
+  | CIProgressEvent
+  | CIEditEvent
+  | CITestEvent
+  | CICostEvent
+  | CIEndEvent;
+
+// ---------------------------------------------------------------------------
+// Answer injection
+// ---------------------------------------------------------------------------
+
+export interface AnswerEntry {
+  match: string;
+  answer: string;
+}
+
+export interface AnswerFile {
+  answers: AnswerEntry[];
+}
+
+// ---------------------------------------------------------------------------
+// Test results
+// ---------------------------------------------------------------------------
+
+export interface TestSummary {
+  passed: number;
+  failed: number;
+  total: number;
+  duration_ms: number;
+}
+
+// ---------------------------------------------------------------------------
+// PR creation
+// ---------------------------------------------------------------------------
+
+export interface PROptions {
+  title: string;
+  body?: string;
+  base?: string;
+  head?: string;
+  draft?: boolean;
+  labels?: string[];
+}
+
+export interface PRResult {
+  url: string;
+  number: number;
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline
+// ---------------------------------------------------------------------------
+
+export type CIPipelineMode = "single" | "plan" | "review" | "supervised";
+
+export interface CIOptions {
+  prompt: string;
+  mode: CIPipelineMode;
+  answersFile?: string;
+  planFile?: string;
+  prNumber?: number;
+  resume?: string;
+  idleTimeoutMs?: number;
+  maxRetries?: number;
+}

package/src/workflow/deployment-workflow.ts

@@ -0,0 +1,153 @@
+/**
+ * Deployment Workflow - Pattern from pi-crew workflow-config.ts
+ * 
+ * Declarative deployment workflow definition.
+ */
+
+export interface DeploymentStep {
+  id: string;
+  name: string;
+  action: "validate" | "build" | "test" | "deploy" | "verify" | "rollback";
+  environment: "staging" | "production" | "preview";
+  dependsOn?: string[];
+  parallelGroup?: string;
+  timeout?: number; // ms
+  retry?: {
+    maxAttempts: number;
+    backoffMs: number;
+  };
+  conditions?: {
+    onlyIf?: string;
+    skipIf?: string;
+  };
+}
+
+export interface DeploymentWorkflow {
+  name: string;
+  description: string;
+  version: string;
+  steps: DeploymentStep[];
+  maxConcurrency?: number;
+  rollbackOnFailure?: boolean;
+}
+
+export interface DeploymentState {
+  workflowId: string;
+  runId: string;
+  status: "pending" | "running" | "completed" | "failed" | "rolled_back";
+  currentStep?: string;
+  completedSteps: string[];
+  failedSteps: string[];
+  startedAt: string;
+  finishedAt?: string;
+}
+
+/**
+ * Create a standard deployment workflow
+ */
+export function createDeploymentWorkflow(
+  options: {
+    name: string;
+    environments?: string[];
+    includeStaging?: boolean;
+  }
+): DeploymentWorkflow {
+  const envs = options.environments ?? ["staging", "production"];
+  
+  const steps: DeploymentStep[] = [
+    { id: "validate", name: "Validate", action: "validate", environment: "staging" as const },
+    { id: "build", name: "Build", action: "build", environment: "staging" as const, dependsOn: ["validate"] },
+    { id: "test", name: "Test", action: "test", environment: "staging" as const, dependsOn: ["build"] },
+  ];
+  
+  if (options.includeStaging !== false) {
+    steps.push({
+      id: "deploy-staging",
+      name: "Deploy to Staging",
+      action: "deploy",
+      environment: "staging",
+      dependsOn: ["test"],
+      retry: { maxAttempts: 3, backoffMs: 5000 },
+    });
+    steps.push({
+      id: "verify-staging",
+      name: "Verify Staging",
+      action: "verify",
+      environment: "staging",
+      dependsOn: ["deploy-staging"],
+    });
+  }
+  
+  if (envs.includes("production")) {
+    steps.push({
+      id: "deploy-production",
+      name: "Deploy to Production",
+      action: "deploy",
+      environment: "production",
+      dependsOn: options.includeStaging !== false ? ["verify-staging"] : ["test"],
+      retry: { maxAttempts: 3, backoffMs: 10000 },
+      conditions: {
+        onlyIf: "BRANCH=main",
+      },
+    });
+  }
+  
+  return {
+    name: options.name,
+    description: `Deployment workflow for ${options.name}`,
+    version: "1.0.0",
+    steps,
+    maxConcurrency: 1,
+    rollbackOnFailure: true,
+  };
+}
+
+/**
+ * Execute a deployment workflow
+ */
+export async function* executeDeploymentWorkflow(
+  workflow: DeploymentWorkflow,
+  executor: (step: DeploymentStep) => Promise<{ success: boolean; error?: string }>
+): AsyncGenerator<DeploymentState> {
+  const state: DeploymentState = {
+    workflowId: workflow.name,
+    runId: `deploy-${Date.now()}`,
+    status: "pending",
+    completedSteps: [],
+    failedSteps: [],
+    startedAt: new Date().toISOString(),
+  };
+  
+  yield state;
+  
+  const stepMap = new Map(workflow.steps.map(s => [s.id, s]));
+  const completed = new Set<string>();
+  
+  for (const step of workflow.steps) {
+    // Check dependencies
+    if (step.dependsOn?.some(dep => !completed.has(dep))) {
+      continue; // Dependencies not met
+    }
+    
+    state.status = "running";
+    state.currentStep = step.id;
+    yield state;
+    
+    const result = await executor(step);
+    
+    if (result.success) {
+      completed.add(step.id);
+      state.completedSteps.push(step.id);
+    } else {
+      state.failedSteps.push(step.id);
+      state.status = "failed";
+      state.finishedAt = new Date().toISOString();
+      yield state;
+      return;
+    }
+  }
+  
+  state.status = "completed";
+  state.finishedAt = new Date().toISOString();
+  yield state;
+}