pi-cicd 0.3.0 → 1.0.1

package/src/deploy/landing-queue.ts

@@ -0,0 +1,222 @@
+/**
+ * Landing Queue - Process deployments in order
+ * Based on gstack /landing-report pattern
+ */
+
+export type DeployStatus = 'pending' | 'deploying' | 'deployed' | 'failed' | 'cancelled';
+export type DeployEnvironment = 'staging' | 'production';
+
+export interface QueuedDeploy {
+  id: string;
+  version: string;
+  environment: DeployEnvironment;
+  status: DeployStatus;
+  createdAt: number;
+  deployedAt?: number;
+  message?: string;
+  logs: string[];
+}
+
+export interface LandingQueueStats {
+  total: number;
+  pending: number;
+  deploying: number;
+  deployed: number;
+  failed: number;
+}
+
+/**
+ * Landing Queue Manager
+ */
+export class LandingQueue {
+  private queue: QueuedDeploy[] = [];
+  private current: QueuedDeploy | null = null;
+
+  /**
+   * Add deployment to queue
+   */
+  enqueue(version: string, environment: DeployEnvironment, message?: string): QueuedDeploy {
+    const deploy: QueuedDeploy = {
+      id: `deploy-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      version,
+      environment,
+      status: 'pending',
+      createdAt: Date.now(),
+      message,
+      logs: [],
+    };
+
+    this.queue.push(deploy);
+    this.log(deploy.id, `Added to queue: ${version} -> ${environment}`);
+
+    return deploy;
+  }
+
+  /**
+   * Get next pending deployment
+   */
+  peek(): QueuedDeploy | undefined {
+    return this.queue.find((d) => d.status === 'pending');
+  }
+
+  /**
+   * Start deploying next item
+   */
+  async startNext(): Promise<QueuedDeploy | null> {
+    const next = this.peek();
+    if (!next) return null;
+
+    // Mark as deploying
+    next.status = 'deploying';
+    this.current = next;
+    this.log(next.id, 'Starting deployment');
+
+    return next;
+  }
+
+  /**
+   * Mark deployment as complete
+   */
+  complete(id: string, success: boolean): void {
+    const deploy = this.queue.find((d) => d.id === id);
+    if (!deploy) return;
+
+    deploy.status = success ? 'deployed' : 'failed';
+    deploy.deployedAt = Date.now();
+    this.log(id, success ? 'Deployment successful' : 'Deployment failed');
+
+    if (this.current?.id === id) {
+      this.current = null;
+    }
+  }
+
+  /**
+   * Cancel a deployment
+   */
+  cancel(id: string): void {
+    const deploy = this.queue.find((d) => d.id === id);
+    if (!deploy) return;
+
+    if (deploy.status === 'deploying') {
+      this.log(id, 'Cannot cancel - deployment in progress');
+      return;
+    }
+
+    deploy.status = 'cancelled';
+    this.log(id, 'Cancelled');
+  }
+
+  /**
+   * Get deployment by ID
+   */
+  get(id: string): QueuedDeploy | undefined {
+    return this.queue.find((d) => d.id === id);
+  }
+
+  /**
+   * Get queue status
+   */
+  getStats(): LandingQueueStats {
+    return {
+      total: this.queue.length,
+      pending: this.queue.filter((d) => d.status === 'pending').length,
+      deploying: this.queue.filter((d) => d.status === 'deploying').length,
+      deployed: this.queue.filter((d) => d.status === 'deployed').length,
+      failed: this.queue.filter((d) => d.status === 'failed').length,
+    };
+  }
+
+  /**
+   * Get all deployments
+   */
+  getAll(): QueuedDeploy[] {
+    return [...this.queue].sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * Get pending deployments
+   */
+  getPending(): QueuedDeploy[] {
+    return this.queue
+      .filter((d) => d.status === 'pending')
+      .sort((a, b) => a.createdAt - b.createdAt);
+  }
+
+  /**
+   * Get current deploying
+   */
+  getCurrent(): QueuedDeploy | null {
+    return this.current;
+  }
+
+  /**
+   * Add log entry
+   */
+  private log(id: string, message: string): void {
+    const deploy = this.queue.find((d) => d.id === id);
+    if (deploy) {
+      deploy.logs.push(`[${new Date().toISOString()}] ${message}`);
+    }
+  }
+
+  /**
+   * Clear completed deployments
+   */
+  clearCompleted(): void {
+    this.queue = this.queue.filter(
+      (d) => d.status === 'pending' || d.status === 'deploying'
+    );
+  }
+
+  /**
+   * Format queue as markdown report
+   */
+  formatReport(): string {
+    const stats = this.getStats();
+    const lines: string[] = [];
+
+    lines.push('## Landing Queue Report\n');
+    lines.push(`**Total:** ${stats.total} | **Pending:** ${stats.pending} | **Deploying:** ${stats.deploying} | **Deployed:** ${stats.deployed} | **Failed:** ${stats.failed}\n`);
+
+    const current = this.getCurrent();
+    if (current) {
+      lines.push('### Currently Deploying\n');
+      lines.push(`**${current.version}** -> ${current.environment}`);
+      lines.push(`Status: ${current.status}`);
+      lines.push('');
+    }
+
+    const pending = this.getPending();
+    if (pending.length > 0) {
+      lines.push('### Queue\n');
+      lines.push('| # | Version | Environment | Message |');
+      lines.push('|---|--------|------------|---------|');
+
+      pending.forEach((d, i) => {
+        lines.push(`| ${i + 1} | ${d.version} | ${d.environment} | ${d.message || '-'} |`);
+      });
+      lines.push('');
+    }
+
+    const recent = this.queue
+      .filter((d) => d.status === 'deployed' || d.status === 'failed')
+      .slice(0, 5);
+
+    if (recent.length > 0) {
+      lines.push('### Recent\n');
+      lines.push('| Version | Environment | Status | Time |');
+      lines.push('|---------|------------|--------|------|');
+
+      for (const d of recent) {
+        const icon = d.status === 'deployed' ? '✅' : '❌';
+        const time = d.deployedAt
+          ? new Date(d.deployedAt).toLocaleTimeString()
+          : '-';
+        lines.push(`| ${d.version} | ${d.environment} | ${icon} ${d.status} | ${time} |`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+}

package/src/headless/answer-injector.ts

@@ -0,0 +1,99 @@
+/**
+ * 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";
+import * as fs from "fs";
+
+/**
+ * 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 = fs.readFileSync(filePath, "utf-8");
+  } 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

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

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

@@ -0,0 +1,90 @@
+/**
+ * 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";
+}