pi-cicd 0.1.1 → 0.3.0

package/src/headless/orchestrator.ts

@@ -1,206 +0,0 @@
-/**
- * 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, type AnswerEntry } from "./answer-injector.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/src/tools/ci_status.ts

@@ -1,137 +0,0 @@
-/**
- * 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

@@ -1,149 +0,0 @@
-/**
- * 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/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "noImplicitAny": true,
-    "exactOptionalPropertyTypes": false,
-    "skipLibCheck": true,
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "types": ["node"]
-  },
-  "include": [
-    "*.ts",
-    "src/**/*.ts",
-    "test/**/*.ts"
-  ]
-}