pi-cicd 1.0.0 → 1.0.2

package/install.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Install script for <PKG-NAME>
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const home = os.homedir();
+const agentDir = path.join(home, ".pi", "agent");
+const pkgName = path.basename(process.cwd());
+const configPath = path.join(agentDir, `${pkgName}.json`);
+
+// Create config directory
+fs.mkdirSync(agentDir, { recursive: true });
+
+// Check if config already exists
+if (!fs.existsSync(configPath)) {
+  const defaultConfig = {
+    enabled: true
+  };
+  fs.writeFileSync(configPath, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf-8");
+  console.log(`Created default ${pkgName} config: ${configPath}`);
+} else {
+  console.log(`${pkgName} config already exists: ${configPath}`);
+}
+
+console.log(`\nInstall the published package in Pi with:`);
+console.log(`  pi install npm:@baphuongna/${pkgName}`);
+console.log(`\nFor local development from a cloned repo:`);
+console.log(`  pi install .`);
+console.log(`\nVerify installation:`);
+console.log(`  pi list\n`);

package/package.json

@@ -1,41 +1,42 @@
 {
   "name": "pi-cicd",
-  "version": "1.0.0",
-  "description": "Pi extension for headless CI mode with structured exit codes, answer injection, and pipeline automation",
-  "author": "baphuongna",
-  "license": "MIT",
+  "version": "1.0.2",
+  "description": "Extension for Pi coding agent",
   "type": "module",
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-coding-agent",
-    "ci",
-    "headless",
-    "automation"
-  ],
+  "main": "./index.ts",
+  "module": "./index.ts",
+  "types": "./index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    }
+  },
   "files": [
     "*.ts",
+    "*.mjs",
     "src/**/*.ts",
+    "skills/**/*",
     "README.md",
-    "AGENTS.md",
-    "tsconfig.json"
+    "docs/",
+    "CHANGELOG.md",
+    "LICENSE"
   ],
-  "scripts": {
-    "check": "npm run typecheck && npm test",
-    "typecheck": "tsc --noEmit",
-    "test": "node --experimental-strip-types --test --test-concurrency=1 --test-timeout=30000 test/unit/*.test.ts"
-  },
   "pi": {
     "extensions": [
       "./index.ts"
     ]
   },
+  "keywords": [
+    "pi",
+    "coding-agent",
+    "extension"
+  ],
+  "author": "BaphuongNA",
+  "license": "MIT",
+  "repository": "https://github.com/baphuongna/pi-cicd",
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
-  },
-  "peerDependenciesMeta": {
-    "@mariozechner/pi-coding-agent": {
-      "optional": true
-    }
+    "typescript": "^5.0.0",
+    "@earendil-works/pi-coding-agent": ">=0.73.0"
   }
-}
+}

package/skills/intelligent-deploy/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: intelligent-deploy
+description: Canary deployment with monitoring and landing queue management
+triggers:
+  - deploy
+  - canary
+  - rollout
+  - landing queue
+  - production
+requirements:
+  tools: [bash]
+  context: [deployment target]
+---
+
+# Intelligent Deploy Skill
+
+## Objective
+Execute safe deployments with canary monitoring, automatic rollback, and landing queue management.
+
+## When to Use
+- When user asks to "deploy" or "ship to production"
+- When running CI/CD pipelines
+- When managing multiple deployments
+- When requiring gradual rollouts with monitoring
+
+## Workflow
+
+### Step 1: Canary Deployment
+```typescript
+import { CanaryDeploy } from '../../src/deploy/canary-deploy';
+
+const canary = new CanaryDeploy({
+  initialPercentage: 10,
+  incrementPercentage: 10,
+  stepInterval: 60000, // 1 minute
+  totalDuration: 300000, // 5 minutes
+  metrics: {
+    successRate: { min: 95 },
+    latency: { max: 500 },
+    errorRate: { max: 5 },
+  },
+});
+
+const result = await canary.deploy({
+  name: 'production',
+  url: 'https://api.example.com',
+  healthy: true,
+});
+
+console.log(canary.formatReport(result));
+```
+
+### Step 2: Landing Queue
+```typescript
+import { LandingQueue } from '../../src/deploy/landing-queue';
+
+const queue = new LandingQueue();
+
+// Add to queue
+queue.enqueue('v1.2.0', 'production', 'New feature release');
+queue.enqueue('v1.2.1', 'production', 'Bug fix');
+
+// Process queue
+while (true) {
+  const next = await queue.startNext();
+  if (!next) break;
+  
+  // Deploy
+  const success = await deploy(next);
+  
+  // Mark complete
+  queue.complete(next.id, success);
+  
+  if (!success) break; // Stop on failure
+}
+```
+
+### Step 3: Monitor and Rollback
+```typescript
+// Automatic rollback on issues
+if (result.rolledBack) {
+  console.log('Deployment rolled back due to issues');
+  await canary.rollback(target);
+}
+```
+
+## Canary Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| initialPercentage | 10% | Starting traffic |
+| incrementPercentage | 10% | Traffic increase per step |
+| stepInterval | 1 min | Time between increments |
+| totalDuration | 5 min | Total deployment time |
+
+### Metrics Thresholds
+
+| Metric | Threshold | Action |
+|--------|-----------|--------|
+| Success Rate | > 95% | Continue |
+| Latency | < 500ms | Continue |
+| Error Rate | < 5% | Continue |
+
+If metrics drop below thresholds:
+- Warning at threshold
+- Auto-rollback at critical level (90% success, 10% errors)
+
+## Landing Queue Commands
+
+### Enqueue Deployment
+```typescript
+queue.enqueue('v1.2.0', 'production', 'Feature release');
+```
+
+### Process Queue
+```typescript
+while (const next = queue.startNext()) {
+  await deploy(next);
+  queue.complete(next.id, success);
+}
+```
+
+### View Status
+```typescript
+console.log(queue.formatReport());
+```
+
+## Examples
+
+### Deploy with Canary
+```
+User: Deploy v1.2.0 to production with canary
+Agent:
+  const result = await canary.deploy({ name: 'production', url: '...', healthy: true });
+  if (result.success) {
+    console.log('Deployment successful!');
+  } else {
+    console.log('Rolled back - check issues');
+  }
+```
+
+### Process Landing Queue
+```
+User: Queue these deployments: v1.2.0, v1.2.1, v1.2.2
+Agent:
+  queue.enqueue('v1.2.0', 'production');
+  queue.enqueue('v1.2.1', 'production');
+  queue.enqueue('v1.2.2', 'staging');
+  
+  const result = await queue.processAll();
+```
+
+### View Queue Status
+```
+User: Show me the current deployment queue
+Agent:
+  console.log(queue.formatReport());
+```
+
+## Output Format
+
+### Canary Report
+```markdown
+## Canary Deployment Report
+**Status:** ✅ SUCCESS
+**Final Traffic:** 100%
+**Rolled Back:** No
+
+### Metrics History
+| Time | Success | Latency | Error Rate |
+|------|---------|---------|------------|
+| 0min | 98.5% | 120ms | 1.2% |
+| 1min | 99.1% | 115ms | 0.8% |
+| 2min | 99.3% | 110ms | 0.5% |
+```
+
+### Landing Queue Report
+```markdown
+## Landing Queue Report
+**Total:** 5 | **Pending:** 2 | **Deploying:** 1 | **Deployed:** 2 | **Failed:** 0
+
+### Currently Deploying
+**v1.2.1** -> production
+Status: deploying
+
+### Queue
+| # | Version | Environment | Message |
+|---|--------|------------|---------|
+| 1 | v1.2.2 | production | Hotfix |
+| 2 | v1.2.3 | staging | New feature |
+```
+
+## Integration
+
+### With pi-pipeline
+```typescript
+// Run as part of ship workflow
+const gates = new QualityGates();
+const gatesResult = await gates.run('pre-push');
+
+if (gatesResult.passed) {
+  const result = await canary.deploy(target);
+  if (!result.success) {
+    throw new Error('Deployment failed');
+  }
+}
+```
+
+### With pi-audit
+```typescript
+// Security scan before deploy
+const shield = new AgentShield();
+const scan = shield.scan(deploymentCode);
+
+if (!scan.passed) {
+  console.log('Security issues must be fixed');
+  process.exit(1);
+}
+```
+
+### With pi-recollect
+```typescript
+// Remember deployment
+await memory.remember(
+  'deployment',
+  `Deployed ${version} to ${environment}`,
+  'observation'
+);
+```

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