pi-cicd 0.3.0 → 1.0.1

package/src/ci/report.ts

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

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

@@ -0,0 +1,99 @@
+/**
+ * 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/deploy/canary-deploy.ts

@@ -0,0 +1,211 @@
+/**
+ * Canary Deployment with Monitoring
+ * Gradual rollout with automatic rollback
+ * Based on gstack /canary pattern
+ */
+
+export interface CanaryConfig {
+  /** Initial traffic percentage for canary */
+  initialPercentage: number;
+  /** Increment per step */
+  incrementPercentage: number;
+  /** Time between increments (ms) */
+  stepInterval: number;
+  /** Total duration before full rollout (ms) */
+  totalDuration: number;
+  /** Metrics to monitor */
+  metrics: {
+    successRate: { min: number };
+    latency: { max: number };
+    errorRate: { max: number };
+  };
+}
+
+export interface CanaryMetrics {
+  timestamp: number;
+  successRate: number;
+  latency: number;
+  errorRate: number;
+  requests: number;
+}
+
+export interface CanaryResult {
+  success: boolean;
+  finalPercentage: number;
+  metrics: CanaryMetrics[];
+  issues: string[];
+  rolledBack: boolean;
+}
+
+export interface DeployTarget {
+  name: string;
+  url: string;
+  healthy: boolean;
+}
+
+/**
+ * Canary Deployment Manager
+ */
+export class CanaryDeploy {
+  private config: CanaryConfig;
+  private metricsHistory: CanaryMetrics[] = [];
+
+  constructor(config?: Partial<CanaryConfig>) {
+    this.config = {
+      initialPercentage: config?.initialPercentage ?? 10,
+      incrementPercentage: config?.incrementPercentage ?? 10,
+      stepInterval: config?.stepInterval ?? 60000, // 1 minute
+      totalDuration: config?.totalDuration ?? 300000, // 5 minutes
+      metrics: config?.metrics ?? {
+        successRate: { min: 95 },
+        latency: { max: 500 },
+        errorRate: { max: 5 },
+      },
+    };
+  }
+
+  /**
+   * Execute canary deployment
+   */
+  async deploy(target: DeployTarget): Promise<CanaryResult> {
+    console.log(`Starting canary deployment to ${target.name}`);
+    console.log(`Initial: ${this.config.initialPercentage}% traffic`);
+
+    const issues: string[] = [];
+    let currentPercentage = this.config.initialPercentage;
+    let rolledBack = false;
+
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < this.config.totalDuration) {
+      // Get current metrics
+      const metrics = await this.getMetrics(target);
+      this.metricsHistory.push(metrics);
+
+      // Check for issues
+      const detectedIssues = this.checkMetrics(metrics);
+      if (detectedIssues.length > 0) {
+        issues.push(...detectedIssues);
+        console.log(`⚠️ Issues detected: ${detectedIssues.join(', ')}`);
+
+        // Auto-rollback on critical issues
+        if (metrics.successRate < 90 || metrics.errorRate > 10) {
+          console.log('🔴 Critical issues - rolling back!');
+          rolledBack = true;
+          break;
+        }
+      }
+
+      // Print status
+      console.log(`[${Math.round((Date.now() - startTime) / 1000)}s] ` +
+        `Traffic: ${currentPercentage}% | ` +
+        `Success: ${metrics.successRate.toFixed(1)}% | ` +
+        `Latency: ${metrics.latency.toFixed(0)}ms`);
+
+      // Wait for next step
+      await this.delay(this.config.stepInterval);
+
+      // Increment traffic
+      currentPercentage = Math.min(100, currentPercentage + this.config.incrementPercentage);
+    }
+
+    return {
+      success: !rolledBack,
+      finalPercentage: rolledBack ? 0 : currentPercentage,
+      metrics: this.metricsHistory,
+      issues,
+      rolledBack,
+    };
+  }
+
+  /**
+   * Get current metrics from target
+   */
+  private async getMetrics(target: DeployTarget): Promise<CanaryMetrics> {
+    // Simulate metrics collection
+    // In production: call monitoring API
+
+    return {
+      timestamp: Date.now(),
+      successRate: 95 + Math.random() * 5,
+      latency: 50 + Math.random() * 100,
+      errorRate: Math.random() * 3,
+      requests: Math.floor(100 + Math.random() * 900),
+    };
+  }
+
+  /**
+   * Check metrics against thresholds
+   */
+  private checkMetrics(metrics: CanaryMetrics): string[] {
+    const issues: string[] = [];
+
+    if (metrics.successRate < this.config.metrics.successRate.min) {
+      issues.push(`Low success rate: ${metrics.successRate.toFixed(1)}%`);
+    }
+
+    if (metrics.latency > this.config.metrics.latency.max) {
+      issues.push(`High latency: ${metrics.latency.toFixed(0)}ms`);
+    }
+
+    if (metrics.errorRate > this.config.metrics.errorRate.max) {
+      issues.push(`High error rate: ${metrics.errorRate.toFixed(1)}%`);
+    }
+
+    return issues;
+  }
+
+  /**
+   * Rollback deployment
+   */
+  async rollback(target: DeployTarget): Promise<void> {
+    console.log(`Rolling back ${target.name}`);
+    // In production: call rollback API
+    await this.delay(1000);
+    console.log('Rollback complete');
+  }
+
+  /**
+   * Get deployment history
+   */
+  getHistory(): CanaryMetrics[] {
+    return [...this.metricsHistory];
+  }
+
+  /**
+   * Generate deployment report
+   */
+  formatReport(result: CanaryResult): string {
+    const lines: string[] = [];
+
+    lines.push('## Canary Deployment Report\n');
+    lines.push(`**Status:** ${result.success ? '✅ SUCCESS' : '❌ FAILED'}`);
+    lines.push(`**Final Traffic:** ${result.finalPercentage}%`);
+    lines.push(`**Rolled Back:** ${result.rolledBack ? 'Yes' : 'No'}\n`);
+
+    if (result.metrics.length > 0) {
+      lines.push('### Metrics History\n');
+      lines.push('| Time | Success | Latency | Error Rate |');
+      lines.push('|------|---------|---------|------------|');
+
+      result.metrics.forEach((m, i) => {
+        lines.push(`| ${i * 1}min | ${m.successRate.toFixed(1)}% | ${m.latency.toFixed(0)}ms | ${m.errorRate.toFixed(1)}% |`);
+      });
+      lines.push('');
+    }
+
+    if (result.issues.length > 0) {
+      lines.push('### Issues Detected\n');
+      for (const issue of result.issues) {
+        lines.push(`- ${issue}`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}