pi-cicd 0.1.1 → 0.3.0

package/src/ci/pr-creator.ts

@@ -1,74 +0,0 @@
-/**
- * pi-ci — PR creation via the GitHub CLI (`gh`).
- *
- * Wraps `gh pr create` with structured error handling.
- */
-
-import { execFile } from "node:child_process";
-import type { PROptions, PRResult } from "../types.ts";
-
-/**
- * Create a pull request using the `gh` CLI.
- *
- * Throws if `gh` is not installed or the command fails.
- */
-export async function createPR(options: PROptions): Promise<PRResult> {
-  const args = ["pr", "create", "--title", options.title];
-
-  if (options.body) {
-    args.push("--body", options.body);
-  }
-  if (options.base) {
-    args.push("--base", options.base);
-  }
-  if (options.head) {
-    args.push("--head", options.head);
-  }
-  if (options.draft) {
-    args.push("--draft");
-  }
-  for (const label of options.labels ?? []) {
-    args.push("--label", label);
-  }
-
-  const output = await runGh(args);
-
-  // Parse the PR URL from the output
-  const urlMatch = output.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
-  if (!urlMatch) {
-    throw new Error(`Failed to parse PR URL from gh output: ${output}`);
-  }
-
-  return {
-    url: urlMatch[0],
-    number: parseInt(urlMatch[1], 10),
-  };
-}
-
-/**
- * Detect the default (base) branch for the current repository.
- */
-export async function detectBaseBranch(): Promise<string> {
-  const output = await runGh(["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"]);
-  return output.trim() || "main";
-}
-
-/**
- * Execute a `gh` command and return stdout.
- */
-function runGh(args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    execFile("gh", args, { timeout: 60_000 }, (err, stdout, stderr) => {
-      if (err) {
-        const message = stderr?.trim() || err.message;
-        if (err.code === "ENOENT") {
-          reject(new Error("gh CLI is not installed. Install it from https://cli.github.com"));
-        } else {
-          reject(new Error(`gh ${args.join(" ")} failed: ${message}`));
-        }
-        return;
-      }
-      resolve(stdout);
-    });
-  });
-}

package/src/ci/report.ts

@@ -1,65 +0,0 @@
-/**
- * pi-ci — CI report generation.
- *
- * Produces JSONL or human-readable summary reports from collected CI events.
- */
-
-import type { CIEvent, CIEndEvent, CICostEvent, CITestEvent } from "../types.ts";
-import { isCIEndEvent, isCICostEvent, isCITestEvent } from "../headless/jsonl-stream.ts";
-
-export interface ReportOptions {
-  format: "jsonl" | "summary";
-}
-
-/**
- * Generate a report from a list of CI events.
- */
-export function generateReport(events: CIEvent[], options?: ReportOptions): string {
-  const format = options?.format ?? "jsonl";
-
-  if (format === "summary") {
-    return generateSummary(events);
-  }
-
-  // JSONL: one event per line
-  return events.map((e) => JSON.stringify(e)).join("\n");
-}
-
-/**
- * Generate a human-readable summary.
- */
-function generateSummary(events: CIEvent[]): string {
-  const lines: string[] = ["=== CI Run Summary ===", ""];
-
-  let totalTestsPassed = 0;
-  let totalTestsFailed = 0;
-  let totalCostUsd = 0;
-  let exitCode = -1;
-  let durationMs = 0;
-
-  for (const event of events) {
-    if (isCITestEvent(event)) {
-      totalTestsPassed += event.passed;
-      totalTestsFailed += event.failed;
-    }
-    if (isCICostEvent(event)) {
-      totalCostUsd += event.cost_usd;
-    }
-    if (isCIEndEvent(event)) {
-      exitCode = event.exit_code;
-      durationMs = event.duration_ms;
-    }
-  }
-
-  lines.push(`Exit Code: ${exitCode}`);
-  lines.push(`Duration:  ${(durationMs / 1000).toFixed(1)}s`);
-  lines.push(`Tests:     ${totalTestsPassed} passed, ${totalTestsFailed} failed`);
-  if (totalCostUsd > 0) {
-    lines.push(`Cost:      $${totalCostUsd.toFixed(4)}`);
-  }
-
-  const status = exitCode === 0 ? "SUCCESS" : exitCode === 10 ? "BLOCKED" : exitCode === 11 ? "CANCELLED" : "ERROR";
-  lines.push(`Status:    ${status}`);
-
-  return lines.join("\n");
-}

package/src/ci/test-runner.ts

@@ -1,129 +0,0 @@
-/**
- * pi-ci — Test result parsing for TAP, Jest, and Vitest output formats.
- */
-
-import type { TestSummary } from "../types.ts";
-
-export type TestOutputFormat = "tap" | "jest" | "vitest";
-
-/**
- * Parse test output and return a summary.
- */
-export function parseTestResults(output: string, format: TestOutputFormat): TestSummary {
-  if (!output || !output.trim()) {
-    return { passed: 0, failed: 0, total: 0, duration_ms: 0 };
-  }
-
-  switch (format) {
-    case "tap":
-      return parseTap(output);
-    case "jest":
-      return parseJest(output);
-    case "vitest":
-      return parseVitest(output);
-    default:
-      return { passed: 0, failed: 0, total: 0, duration_ms: 0 };
-  }
-}
-
-/**
- * Parse TAP (Test Anything Protocol) output.
- *
- * Example:
- *   1..5
- *   ok 1 - first test
- *   not ok 2 - failing test
- *   ok 3 - third test
- */
-function parseTap(output: string): TestSummary {
-  let passed = 0;
-  let failed = 0;
-
-  const lines = output.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("ok ")) {
-      passed++;
-    } else if (trimmed.startsWith("not ok ")) {
-      failed++;
-    }
-  }
-
-  return {
-    passed,
-    failed,
-    total: passed + failed,
-    duration_ms: 0, // TAP doesn't have standard duration
-  };
-}
-
-/**
- * Parse Jest-style test output.
- *
- * Looks for patterns like:
- *   Tests:       5 passed, 2 failed, 7 total
- *   Time:        3.456 s
- */
-function parseJest(output: string): TestSummary {
-  let passed = 0;
-  let failed = 0;
-  let total = 0;
-  let durationMs = 0;
-
-  // Match test summary line
-  const testMatch = output.match(
-    /Tests:\s*(\d+)\s*passed(?:,\s*(\d+)\s*failed)?(?:,\s*(\d+)\s*total)?/,
-  );
-  if (testMatch) {
-    passed = parseInt(testMatch[1], 10);
-    failed = parseInt(testMatch[2] || "0", 10);
-    total = parseInt(testMatch[3] || String(passed + failed), 10);
-  } else {
-    // Fallback: count individual test lines
-    const passMatches = output.match(/✓|PASS/g);
-    const failMatches = output.match(/✕|FAIL/g);
-    passed = passMatches?.length ?? 0;
-    failed = failMatches?.length ?? 0;
-    total = passed + failed;
-  }
-
-  // Match time
-  const timeMatch = output.match(/Time:\s*([\d.]+)\s*s/);
-  if (timeMatch) {
-    durationMs = Math.round(parseFloat(timeMatch[1]) * 1000);
-  }
-
-  return { passed, failed, total, duration_ms: durationMs };
-}
-
-/**
- * Parse Vitest-style test output.
- *
- * Looks for patterns like:
- *   Tests  5 passed | 2 failed (7)
- *   Duration  3.45s
- */
-function parseVitest(output: string): TestSummary {
-  let passed = 0;
-  let failed = 0;
-  let total = 0;
-  let durationMs = 0;
-
-  // Match test summary line: "Tests  5 passed | 2 failed (7)"
-  const testMatch = output.match(
-    /Tests\s+(\d+)\s+passed(?:\s*\|\s*(\d+)\s+failed)?(?:\s*\((\d+)\))?/,
-  );
-  if (testMatch) {
-    passed = parseInt(testMatch[1], 10);
-    failed = parseInt(testMatch[2] || "0", 10);
-    total = parseInt(testMatch[3] || String(passed + failed), 10);
-  }
-
-  // Match duration: "Duration  3.45s"
-  const durMatch = output.match(/Duration\s+([\d.]+)s/);
-  if (durMatch) {
-    durationMs = Math.round(parseFloat(durMatch[1]) * 1000);
-  }
-
-  return { passed, failed, total, duration_ms: durationMs };
-}

package/src/config.ts

@@ -1,99 +0,0 @@
-/**
- * pi-ci — Configuration loading and defaults.
- *
- * Reads `.pi/pi-ci.json` from the given directory (or cwd) and merges with defaults.
- */
-
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-export interface PiCiReportConfig {
-  format: "jsonl" | "summary";
-  includeCost: boolean;
-  includeEdits: boolean;
-  includeTests: boolean;
-}
-
-export interface PiCiExitCodeConfig {
-  success: number;
-  error: number;
-  blocked: number;
-  cancelled: number;
-  needsInput: number;
-}
-
-export interface PiCiConfig {
-  enabled: boolean;
-  idleTimeoutMs: number;
-  maxRetries: number;
-  retryBackoffMaxMs: number;
-  exitCodes: PiCiExitCodeConfig;
-  report: PiCiReportConfig;
-}
-
-const DEFAULT_CONFIG: PiCiConfig = {
-  enabled: true,
-  idleTimeoutMs: 15_000,
-  maxRetries: 3,
-  retryBackoffMaxMs: 30_000,
-  exitCodes: {
-    success: 0,
-    error: 1,
-    blocked: 10,
-    cancelled: 11,
-    needsInput: 12,
-  },
-  report: {
-    format: "jsonl",
-    includeCost: true,
-    includeEdits: true,
-    includeTests: true,
-  },
-};
-
-/**
- * Load pi-ci configuration from `.pi/pi-ci.json` (if present) merged with defaults.
- */
-export async function loadCiConfig(cwd?: string): Promise<PiCiConfig> {
-  const dir = cwd ?? process.cwd();
-  const configPath = join(dir, ".pi", "pi-ci.json");
-
-  let text: string;
-  try {
-    text = await readFile(configPath, "utf-8");
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-
-  const raw: unknown = JSON.parse(text);
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return { ...DEFAULT_CONFIG };
-  }
-
-  const user = raw as Record<string, unknown>;
-  return {
-    enabled: typeof user.enabled === "boolean" ? user.enabled : DEFAULT_CONFIG.enabled,
-    idleTimeoutMs:
-      typeof user.idleTimeoutMs === "number" ? user.idleTimeoutMs : DEFAULT_CONFIG.idleTimeoutMs,
-    maxRetries:
-      typeof user.maxRetries === "number" ? user.maxRetries : DEFAULT_CONFIG.maxRetries,
-    retryBackoffMaxMs:
-      typeof user.retryBackoffMaxMs === "number"
-        ? user.retryBackoffMaxMs
-        : DEFAULT_CONFIG.retryBackoffMaxMs,
-    exitCodes: {
-      ...DEFAULT_CONFIG.exitCodes,
-      ...(typeof user.exitCodes === "object" && user.exitCodes !== null
-        ? (user.exitCodes as Partial<PiCiExitCodeConfig>)
-        : {}),
-    },
-    report: {
-      ...DEFAULT_CONFIG.report,
-      ...(typeof user.report === "object" && user.report !== null
-        ? (user.report as Partial<PiCiReportConfig>)
-        : {}),
-    },
-  };
-}
-
-export { DEFAULT_CONFIG };

package/src/headless/answer-injector.ts

@@ -1,98 +0,0 @@
-/**
- * pi-ci — Answer injection from a JSON file.
- *
- * When Pi encounters an interactive prompt in CI mode, it consults an
- * answers file for a pre-supplied response.
- */
-
-import type { AnswerEntry, AnswerFile } from "../types.ts";
-
-/**
- * Read and validate an answers JSON file.
- *
- * - Returns an empty array if the file cannot be read.
- * - Skips entries that are missing `match` or `answer` fields.
- * - Throws on invalid JSON.
- */
-export async function loadAnswers(filePath: string): Promise<AnswerEntry[]> {
-  let text: string;
-  try {
-    text = await Bun.file(filePath).text();
-  } catch {
-    return [];
-  }
-
-  const raw: unknown = JSON.parse(text);
-
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new Error(`Answers file must contain a JSON object with an "answers" array`);
-  }
-
-  const obj = raw as Record<string, unknown>;
-  if (!Array.isArray(obj.answers)) {
-    throw new Error(`Answers file must contain an "answers" array`);
-  }
-
-  const entries: AnswerEntry[] = [];
-  for (const item of obj.answers) {
-    if (
-      typeof item === "object" &&
-      item !== null &&
-      typeof (item as Record<string, unknown>).match === "string" &&
-      typeof (item as Record<string, unknown>).answer === "string"
-    ) {
-      entries.push(item as AnswerEntry);
-    }
-    // Silently skip malformed entries
-  }
-
-  return entries;
-}
-
-/**
- * Synchronous variant that reads from a string (useful for testing).
- */
-export function parseAnswers(jsonText: string): AnswerEntry[] {
-  const raw: unknown = JSON.parse(jsonText);
-
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new Error(`Answers file must contain a JSON object with an "answers" array`);
-  }
-
-  const obj = raw as Record<string, unknown>;
-  if (!Array.isArray(obj.answers)) {
-    throw new Error(`Answers file must contain an "answers" array`);
-  }
-
-  const entries: AnswerEntry[] = [];
-  for (const item of obj.answers) {
-    if (
-      typeof item === "object" &&
-      item !== null &&
-      typeof (item as Record<string, unknown>).match === "string" &&
-      typeof (item as Record<string, unknown>).answer === "string"
-    ) {
-      entries.push(item as AnswerEntry);
-    }
-  }
-
-  return entries;
-}
-
-/**
- * Find a matching answer for the given prompt using substring matching.
- *
- * Returns the first answer whose `match` is found as a substring of `prompt`,
- * or `undefined` if no match is found.
- */
-export function matchAnswer(
-  entries: AnswerEntry[],
-  prompt: string,
-): string | undefined {
-  for (const entry of entries) {
-    if (prompt.includes(entry.match)) {
-      return entry.answer;
-    }
-  }
-  return undefined;
-}

package/src/headless/exit-codes.ts

@@ -1,32 +0,0 @@
-/**
- * pi-ci — Exit code resolution helpers.
- */
-
-import { EXIT_CODES, type ExitCode } from "../types.ts";
-
-/**
- * Map a symbolic status string to a numeric exit code.
- *
- * Unknown / unexpected statuses resolve to ERROR (1).
- */
-export function resolveExitCode(status: string): ExitCode {
-  switch (status) {
-    case "success":
-      return EXIT_CODES.SUCCESS;
-    case "error":
-    case "timeout":
-      return EXIT_CODES.ERROR;
-    case "blocked":
-      return EXIT_CODES.BLOCKED;
-    case "cancelled":
-      return EXIT_CODES.CANCELLED;
-    case "needs_input":
-    case "needs-input":
-      return EXIT_CODES.NEEDS_INPUT;
-    default:
-      return EXIT_CODES.ERROR;
-  }
-}
-
-export { EXIT_CODES };
-export type { ExitCode };

package/src/headless/idle-detector.ts

@@ -1,76 +0,0 @@
-/**
- * pi-ci — Idle timeout detection.
- *
- * If no activity is detected within the configured timeout, the callback fires.
- */
-
-export interface IdleDetectorOptions {
-  /** Timeout in milliseconds. Default: 15 000. */
-  idleTimeoutMs?: number;
-  /** Called when the idle timeout is reached. */
-  onTimeout: () => void;
-}
-
-const DEFAULT_IDLE_TIMEOUT_MS = 15_000;
-
-export class IdleDetector {
-  private readonly idleTimeoutMs: number;
-  private readonly onTimeout: () => void;
-  private timer: ReturnType<typeof setTimeout> | null = null;
-  private _running = false;
-  private _fired = false;
-
-  constructor(options: IdleDetectorOptions) {
-    this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-    this.onTimeout = options.onTimeout;
-  }
-
-  /** Whether the detector is currently running. */
-  get running(): boolean {
-    return this._running;
-  }
-
-  /** Whether the timeout has already fired. */
-  get fired(): boolean {
-    return this._fired;
-  }
-
-  /** Start the idle timer. Safe to call multiple times (no-op if already running). */
-  start(): void {
-    if (this._running) return;
-    this._running = true;
-    this._fired = false;
-    this.scheduleTimer();
-  }
-
-  /** Reset the idle timer. If not running, this is a no-op. */
-  reset(): void {
-    if (!this._running) return;
-    this.clearTimer();
-    this.scheduleTimer();
-  }
-
-  /** Stop the idle timer. */
-  stop(): void {
-    this._running = false;
-    this._fired = false;
-    this.clearTimer();
-  }
-
-  private scheduleTimer(): void {
-    this.timer = setTimeout(() => {
-      if (this._running) {
-        this._running = false;
-        this._fired = true;
-        this.onTimeout();
-      }
-    }, this.idleTimeoutMs);
-  }
-
-  private clearTimer(): void {
-    if (this.timer !== null) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-}

package/src/headless/jsonl-stream.ts

@@ -1,90 +0,0 @@
-/**
- * pi-ci — JSONL event stream utilities.
- *
- * Writes CI events as single-line JSON to a writable stream and provides
- * type-guard helpers for event discrimination.
- */
-
-import type { Writable } from "node:stream";
-import type {
-  CIEvent,
-  CIStartEvent,
-  CIProgressEvent,
-  CIEditEvent,
-  CITestEvent,
-  CICostEvent,
-  CIEndEvent,
-} from "../types.ts";
-
-// ---------------------------------------------------------------------------
-// Write helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Ensure an event has a timestamp, injecting `now` if missing.
- */
-function ensureTimestamp<T extends CIEvent>(event: T): T & { timestamp: string } {
-  if (!event.timestamp) {
-    return { ...event, timestamp: new Date().toISOString() };
-  }
-  return event as T & { timestamp: string };
-}
-
-/**
- * Serialise a CI event and write it as a single JSONL line to the stream.
- */
-export function writeCIEvent(stream: Writable, event: CIEvent): void {
-  const stamped = ensureTimestamp(event);
-  stream.write(JSON.stringify(stamped) + "\n");
-}
-
-// ---------------------------------------------------------------------------
-// Event emitter (collects events for reporting)
-// ---------------------------------------------------------------------------
-
-export class CIEventCollector {
-  private readonly events: CIEvent[] = [];
-
-  /** Record an event. Auto-fills timestamp if missing. */
-  emit(event: CIEvent): void {
-    this.events.push(ensureTimestamp(event));
-  }
-
-  /** Return all collected events in order. */
-  all(): CIEvent[] {
-    return [...this.events];
-  }
-
-  /** Reset the collector. */
-  clear(): void {
-    this.events.length = 0;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Type guards
-// ---------------------------------------------------------------------------
-
-export function isCIStartEvent(e: CIEvent): e is CIStartEvent {
-  return e.type === "ci_start";
-}
-
-export function isCIProgressEvent(e: CIEvent): e is CIProgressEvent {
-  return e.type === "ci_progress";
-}
-
-export function isCIEditEvent(e: CIEvent): e is CIEditEvent {
-  return e.type === "ci_edit";
-}
-
-export function isCITestEvent(e: CIEvent): e is CITestEvent {
-  return e.type === "ci_test";
-}
-
-export function isCICostEvent(e: CIEvent): e is CICostEvent {
-  return e.type === "ci_cost";
-}
-
-export function isCIEndEvent(e: CIEvent): e is CIEndEvent {
-  return e.type === "ci_end";
-}