pi-cicd 1.0.4 → 1.0.6

package/docs/stories/US-001-intelligent-deploy-tool.md

@@ -0,0 +1,27 @@
+# US-001: Intelligent Deploy Tool
+
+## User Story
+As an agent, I want to monitor CI/CD pipelines, manage canary deployments, and track landing queues so that I can safely deploy changes to production.
+
+## Status
+- [x] Implemented
+
+## Commands
+- `/ci` - CI status command
+
+## Features
+- CI run tracking
+- Canary deployment support
+- Landing queue management
+- Exit code resolution
+
+## Triggers
+- "deploy", "canary", "rollout", "landing queue", "production"
+
+## Acceptance Criteria
+- [x] CI status command shows run information
+- [x] Exit codes are properly resolved
+- [x] Can track deployment progress
+
+## Notes
+See `skills/intelligent-deploy/SKILL.md` for detailed usage.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cicd",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Extension for Pi coding agent",
   "type": "module",
   "main": "./index.ts",

package/skills/intelligent-deploy/SKILL.md

@@ -1,229 +1,133 @@
 ---
 name: intelligent-deploy
-description: Canary deployment with monitoring and landing queue management
+description: CI/CD pipeline monitoring, canary deployment management, and landing queue orchestration
 triggers:
   - deploy
   - canary
   - rollout
   - landing queue
   - production
+  - CI status
+  - pipeline
+  - release
+  - build
 requirements:
   tools: [bash]
-  context: [deployment target]
+  context: [CI configuration, deployment scripts]
 ---
 
 # Intelligent Deploy Skill
 
 ## Objective
-Execute safe deployments with canary monitoring, automatic rollback, and landing queue management.
+Monitor CI/CD pipelines, manage canary deployments, and track landing queues for safe production releases.
 
-## 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';
+## Commands Available
+- `/ci` - Show CI status
 
-const queue = new LandingQueue();
+## When to Use
+- When deploying to production
+- When monitoring CI/CD pipelines
+- When managing canary releases
+- When tracking landing queues
+- When investigating build failures
 
-// Add to queue
-queue.enqueue('v1.2.0', 'production', 'New feature release');
-queue.enqueue('v1.2.1', 'production', 'Bug fix');
+## CI Status Command
 
-// 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
-}
+### Usage
 ```
-
-### 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);
-}
+/ci [run-id]
 ```
 
-## Canary Configuration
+Shows:
+- Current/last CI run status
+- Exit codes
+- Duration
+- Events
 
-| 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 |
+### Exit Codes
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | General failure |
+| 2 | Misuse/Invalid input |
+| 3 | Configuration error |
+| 124 | Timeout |
+| 137 | SIGKILL (OOM) |
 
-### Metrics Thresholds
+## Deployment Strategies
 
-| Metric | Threshold | Action |
-|--------|-----------|--------|
-| Success Rate | > 95% | Continue |
-| Latency | < 500ms | Continue |
-| Error Rate | < 5% | Continue |
+### Canary Deployment
+1. Deploy to small percentage
+2. Monitor metrics
+3. Gradually increase
+4. Full rollout or rollback
 
-If metrics drop below thresholds:
-- Warning at threshold
-- Auto-rollback at critical level (90% success, 10% errors)
+### Landing Queue
+- Queue changes for controlled rollout
+- Automatic promotion
+- Manual gates for risky changes
 
-## Landing Queue Commands
+## Pipeline Monitoring
 
-### Enqueue Deployment
-```typescript
-queue.enqueue('v1.2.0', 'production', 'Feature release');
+### Status Check
 ```
-
-### Process Queue
-```typescript
-while (const next = queue.startNext()) {
-  await deploy(next);
-  queue.complete(next.id, success);
-}
+/ci
 ```
 
-### View Status
-```typescript
-console.log(queue.formatReport());
-```
+Returns:
+- Run ID
+- Start time
+- Events (pass/fail)
+- Exit code
+- Duration
+
+### Historical Analysis
+Track patterns in:
+- Build times
+- Failure rates
+- Flaky tests
 
 ## Examples
 
-### Deploy with Canary
+### Check CI Status
 ```
-User: Deploy v1.2.0 to production with canary
+User: What's the CI status?
 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');
-  }
+  /ci
 ```
 
-### Process Landing Queue
+### Check Specific Run
 ```
-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();
+  /ci run-123
 ```
 
-### View Queue Status
+### Analyze Failure
 ```
-User: Show me the current deployment queue
+User: Why did the build fail?
 Agent:
-  console.log(queue.formatReport());
+  /ci
+  # Analyze events and exit code
 ```
 
-## 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
+## Configuration
 
-### Queue
-| # | Version | Environment | Message |
-|---|--------|------------|---------|
-| 1 | v1.2.2 | production | Hotfix |
-| 2 | v1.2.3 | staging | New feature |
+### Pipeline Config
+```yaml
+ci:
+  timeout: 300
+  retry: 2
+  parallel: true
+  
+deploy:
+  strategy: canary
+  canary:
+    initial: 5%
+    increment: 10%
+    pause: 5m
 ```
 
 ## 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'
-);
-```
+- With pi-pipeline for verification gates
+- With pi-debug for error investigation
+- With pi-render for status display

package/src/commands/command-registry.ts

@@ -0,0 +1,186 @@
+/**
+ * Command Registry Pattern
+ * 
+ * Registry for command handlers with validation and aliases.
+ * 
+ * Inspired by gstack and pi-hermes-memory patterns.
+ */
+
+export interface CommandDefinition<T = unknown> {
+  /** Command name (e.g., "deploy", "ci-status") */
+  name: string;
+  /** Short description */
+  description?: string;
+  /** Longer description */
+  help?: string;
+  /** Aliases for the command */
+  aliases?: string[];
+  /** Parameter schema */
+  params?: T;
+  /** Examples for help */
+  examples?: Array<{ cmd: string; desc: string }>;
+}
+
+export interface CommandHandler<T = unknown> {
+  /** Execute the command */
+  execute(params: T, context: CommandContext): Promise<CommandResult>;
+  /** Validate parameters before execution */
+  validate?(params: T): ValidationResult;
+}
+
+export interface CommandContext {
+  /** Current working directory */
+  cwd: string;
+  /** User environment */
+  env: Record<string, string>;
+  /** Logger */
+  log: Logger;
+  /** Config store */
+  config: ConfigStore;
+}
+
+export interface CommandResult {
+  /** Exit code (0 = success) */
+  code: number;
+  /** Output to stdout */
+  output?: string;
+  /** Output to stderr */
+  error?: string;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors?: string[];
+}
+
+export interface Logger {
+  info(msg: string): void;
+  warn(msg: string): void;
+  error(msg: string): void;
+  debug(msg: string): void;
+}
+
+export interface ConfigStore {
+  get<T>(key: string, defaultValue?: T): T | undefined;
+  set<T>(key: string, value: T): void;
+}
+
+/**
+ * Command registry for managing available commands.
+ */
+export class CommandRegistry {
+  private commands = new Map<string, CommandHandler>();
+  private definitions = new Map<string, CommandDefinition>();
+  private aliases = new Map<string, string>();
+
+  /**
+   * Register a command.
+   */
+  register<T = unknown>(
+    definition: CommandDefinition<T>,
+    handler: CommandHandler<T>
+  ): void {
+    this.commands.set(definition.name, handler as CommandHandler);
+    this.definitions.set(definition.name, definition);
+
+    // Register aliases
+    for (const alias of definition.aliases ?? []) {
+      this.aliases.set(alias, definition.name);
+    }
+  }
+
+  /**
+   * Execute a command by name.
+   */
+  async execute(
+    name: string,
+    params: unknown,
+    context: CommandContext
+  ): Promise<CommandResult> {
+    // Resolve alias
+    const resolved = this.aliases.get(name) ?? name;
+
+    // Find command
+    const handler = this.commands.get(resolved);
+    if (!handler) {
+      return {
+        code: 1,
+        error: `Unknown command: ${name}`,
+      };
+    }
+
+    // Validate
+    if (handler.validate) {
+      const validation = handler.validate(params);
+      if (!validation.valid) {
+        return {
+          code: 1,
+          error: `Validation failed: ${validation.errors?.join(", ")}`,
+        };
+      }
+    }
+
+    // Execute
+    try {
+      return await handler.execute(params, context);
+    } catch (error) {
+      return {
+        code: 1,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Get command definition.
+   */
+  getDefinition(name: string): CommandDefinition | undefined {
+    const resolved = this.aliases.get(name) ?? name;
+    return this.definitions.get(resolved);
+  }
+
+  /**
+   * List all command names.
+   */
+  listCommands(): string[] {
+    return Array.from(this.definitions.keys()).sort();
+  }
+
+  /**
+   * Get help text for a command.
+   */
+  getHelp(name: string): string | undefined {
+    const def = this.getDefinition(name);
+    if (!def) return undefined;
+
+    let help = `# ${def.name}`;
+    if (def.aliases?.length) {
+      help += ` (alias: ${def.aliases.join(", ")})`;
+    }
+    help += "\n\n";
+
+    if (def.description) {
+      help += `${def.description}\n\n`;
+    }
+
+    if (def.help) {
+      help += `${def.help}\n\n`;
+    }
+
+    if (def.examples?.length) {
+      help += "## Examples\n\n";
+      for (const ex of def.examples) {
+        help += `\`${ex.cmd}\`\n${ex.desc}\n\n`;
+      }
+    }
+
+    return help;
+  }
+}
+
+/**
+ * Create a command registry.
+ */
+export function createCommandRegistry(): CommandRegistry {
+  return new CommandRegistry();
+}