pi-cicd 1.0.0 → 1.0.2

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

@@ -6,6 +6,7 @@
  */
 
 import type { AnswerEntry, AnswerFile } from "../types.ts";
+import * as fs from "fs";
 
 /**
  * Read and validate an answers JSON file.
@@ -17,7 +18,7 @@ import type { AnswerEntry, AnswerFile } from "../types.ts";
 export async function loadAnswers(filePath: string): Promise<AnswerEntry[]> {
   let text: string;
   try {
-    text = await Bun.file(filePath).text();
+    text = fs.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }

package/src/headless/orchestrator.ts

@@ -8,7 +8,8 @@
 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 { 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";

package/src/index.ts

@@ -0,0 +1,52 @@
+/**
+ * pi-ci — Pi extension entry point.
+ *
+ * Registers the /ci status command and CI lifecycle hooks.
+ */
+
+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";
+export { loadAnswers, matchAnswer, parseAnswers } from "./src/headless/answer-injector.ts";
+export { IdleDetector } from "./src/headless/idle-detector.ts";
+export { CIEventCollector, writeCIEvent } from "./src/headless/jsonl-stream.ts";
+export { HeadlessOrchestrator } from "./src/headless/orchestrator.ts";
+export { CIPipeline } from "./src/ci/pipeline.ts";
+export { createPR, detectBaseBranch } from "./src/ci/pr-creator.ts";
+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: ExtensionAPI): void {
+  // Register /ci status command
+  if (pi.registerCommand) {
+    pi.registerCommand("ci", (args: unknown) => {
+      return ciStatusHandler(args);
+    });
+  }
+}

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;
+}

package/AGENTS.md

@@ -1,25 +0,0 @@
-# pi-ci Development Notes
-
-Pi extension for headless CI mode.
-
-## Rules
-
-- Keep `index.ts` minimal; re-export from `src/` modules.
-- Avoid `any`; use `unknown` plus validation.
-- After code changes, run `npm test` from `pi-ci/` unless explicitly told not to.
-
-## Important commands
-
-```bash
-npm test
-npm run typecheck
-```
-
-## Important paths
-
-- `index.ts` — extension entry point
-- `src/headless/` — core headless mode (exit codes, answers, idle, JSONL, orchestrator)
-- `src/ci/` — CI pipeline, PR creation, test runner, reports
-- `src/tools/` — /ci status command
-- `src/config.ts` — configuration loading
-- `test/unit/` — unit tests

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"
-  ]
-}