claude-cli-advanced-starter-pack 1.0.16 → 1.8.0

package/templates/scripts/phase-validation-gates.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+/**
+ * Phase Validation Gates
+ *
+ * 5-gate validation before phase transitions:
+ * 1. EXIST - Required files and artifacts exist
+ * 2. INIT - Initialization completed successfully
+ * 3. REGISTER - Components registered/configured
+ * 4. INVOKE - Functionality works when invoked
+ * 5. PROPAGATE - Changes propagated to dependent systems
+ *
+ * Usage:
+ *   node phase-validation-gates.js --phase 1 --config ./validation.json
+ *   node phase-validation-gates.js --progress ./PROGRESS.json
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { resolve } from 'path';
+
+const GATES = ['EXIST', 'INIT', 'REGISTER', 'INVOKE', 'PROPAGATE'];
+
+class PhaseValidator {
+  constructor(options = {}) {
+    this.phase = options.phase;
+    this.configPath = options.configPath;
+    this.progressPath = options.progressPath || 'PROGRESS.json';
+    this.verbose = options.verbose || false;
+    this.config = null;
+    this.results = {
+      phase: this.phase,
+      gates: {},
+      passed: false,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  async validate() {
+    await this.loadConfig();
+
+    console.log(`\n🔒 Phase ${this.phase} Validation\n`);
+    console.log('Gate          Status    Checks');
+    console.log('-'.repeat(60));
+
+    for (const gate of GATES) {
+      const gateConfig = this.config.gates?.[gate] || {};
+      const result = await this.validateGate(gate, gateConfig);
+      this.results.gates[gate] = result;
+    }
+
+    this.results.passed = Object.values(this.results.gates)
+      .every(g => g.passed);
+
+    this.printSummary();
+    return this.results;
+  }
+
+  async loadConfig() {
+    if (this.configPath && existsSync(this.configPath)) {
+      this.config = JSON.parse(readFileSync(this.configPath, 'utf8'));
+    } else if (existsSync(this.progressPath)) {
+      const progress = JSON.parse(readFileSync(this.progressPath, 'utf8'));
+      this.config = progress.phases?.[this.phase - 1]?.validation || {};
+    } else {
+      this.config = this.getDefaultConfig();
+    }
+  }
+
+  getDefaultConfig() {
+    return {
+      gates: {
+        EXIST: {
+          files: ['package.json'],
+          directories: ['src/', 'node_modules/'],
+        },
+        INIT: {
+          commands: ['npm --version'],
+        },
+        REGISTER: {
+          files: ['.claude/settings.json'],
+        },
+        INVOKE: {
+          commands: ['npm run --silent test 2>/dev/null || echo "no tests"'],
+        },
+        PROPAGATE: {
+          commands: ['git status --porcelain'],
+          expectEmpty: true,
+        },
+      },
+    };
+  }
+
+  async validateGate(gate, config) {
+    const result = {
+      gate,
+      passed: true,
+      checks: [],
+      errors: [],
+    };
+
+    try {
+      switch (gate) {
+        case 'EXIST':
+          await this.checkExist(config, result);
+          break;
+        case 'INIT':
+          await this.checkInit(config, result);
+          break;
+        case 'REGISTER':
+          await this.checkRegister(config, result);
+          break;
+        case 'INVOKE':
+          await this.checkInvoke(config, result);
+          break;
+        case 'PROPAGATE':
+          await this.checkPropagate(config, result);
+          break;
+      }
+    } catch (error) {
+      result.passed = false;
+      result.errors.push(error.message);
+    }
+
+    const icon = result.passed ? '✅' : '❌';
+    const checkCount = `${result.checks.filter(c => c.passed).length}/${result.checks.length}`;
+    console.log(`${gate.padEnd(12)}  ${icon}        ${checkCount} checks passed`);
+
+    if (this.verbose && result.errors.length > 0) {
+      for (const error of result.errors) {
+        console.log(`              └─ ${error}`);
+      }
+    }
+
+    return result;
+  }
+
+  async checkExist(config, result) {
+    // Check files
+    for (const file of config.files || []) {
+      const exists = existsSync(resolve(process.cwd(), file));
+      result.checks.push({ type: 'file', path: file, passed: exists });
+      if (!exists) {
+        result.passed = false;
+        result.errors.push(`Missing file: ${file}`);
+      }
+    }
+
+    // Check directories
+    for (const dir of config.directories || []) {
+      const exists = existsSync(resolve(process.cwd(), dir));
+      result.checks.push({ type: 'directory', path: dir, passed: exists });
+      if (!exists) {
+        result.passed = false;
+        result.errors.push(`Missing directory: ${dir}`);
+      }
+    }
+  }
+
+  async checkInit(config, result) {
+    // Run initialization check commands
+    for (const cmd of config.commands || []) {
+      try {
+        execSync(cmd, { encoding: 'utf8', stdio: 'pipe' });
+        result.checks.push({ type: 'command', command: cmd, passed: true });
+      } catch (error) {
+        result.passed = false;
+        result.checks.push({ type: 'command', command: cmd, passed: false });
+        result.errors.push(`Command failed: ${cmd}`);
+      }
+    }
+
+    // Check environment variables
+    for (const envVar of config.envVars || []) {
+      const exists = !!process.env[envVar];
+      result.checks.push({ type: 'envVar', name: envVar, passed: exists });
+      if (!exists) {
+        result.passed = false;
+        result.errors.push(`Missing env var: ${envVar}`);
+      }
+    }
+  }
+
+  async checkRegister(config, result) {
+    // Check config files contain expected content
+    for (const file of config.files || []) {
+      const filePath = resolve(process.cwd(), file);
+      const exists = existsSync(filePath);
+      result.checks.push({ type: 'config', path: file, passed: exists });
+
+      if (!exists) {
+        result.passed = false;
+        result.errors.push(`Missing config: ${file}`);
+      } else if (config.contains?.[file]) {
+        const content = readFileSync(filePath, 'utf8');
+        for (const expected of config.contains[file]) {
+          const found = content.includes(expected);
+          result.checks.push({ type: 'content', file, expected, passed: found });
+          if (!found) {
+            result.passed = false;
+            result.errors.push(`Missing in ${file}: ${expected}`);
+          }
+        }
+      }
+    }
+  }
+
+  async checkInvoke(config, result) {
+    // Run functionality tests
+    for (const cmd of config.commands || []) {
+      try {
+        const output = execSync(cmd, { encoding: 'utf8', stdio: 'pipe' });
+
+        if (config.expectOutput?.[cmd]) {
+          const expected = config.expectOutput[cmd];
+          const matches = output.includes(expected);
+          result.checks.push({ type: 'invoke', command: cmd, passed: matches });
+          if (!matches) {
+            result.passed = false;
+            result.errors.push(`Output mismatch for: ${cmd}`);
+          }
+        } else {
+          result.checks.push({ type: 'invoke', command: cmd, passed: true });
+        }
+      } catch (error) {
+        if (!config.allowFailure?.includes(cmd)) {
+          result.passed = false;
+          result.checks.push({ type: 'invoke', command: cmd, passed: false });
+          result.errors.push(`Invoke failed: ${cmd}`);
+        }
+      }
+    }
+  }
+
+  async checkPropagate(config, result) {
+    // Check that changes are propagated (git clean, deps synced, etc.)
+    for (const cmd of config.commands || []) {
+      try {
+        const output = execSync(cmd, { encoding: 'utf8', stdio: 'pipe' });
+
+        if (config.expectEmpty) {
+          const isEmpty = output.trim() === '';
+          result.checks.push({ type: 'propagate', command: cmd, passed: isEmpty });
+          if (!isEmpty) {
+            result.passed = false;
+            result.errors.push(`Expected empty output: ${cmd}`);
+          }
+        } else {
+          result.checks.push({ type: 'propagate', command: cmd, passed: true });
+        }
+      } catch (error) {
+        result.passed = false;
+        result.checks.push({ type: 'propagate', command: cmd, passed: false });
+        result.errors.push(`Propagate check failed: ${cmd}`);
+      }
+    }
+  }
+
+  printSummary() {
+    console.log('\n' + '='.repeat(60));
+    console.log(`Phase ${this.phase} Validation: ${this.results.passed ? '✅ PASSED' : '❌ FAILED'}`);
+    console.log('='.repeat(60));
+
+    if (!this.results.passed) {
+      console.log('\n❌ Failed Gates:');
+      for (const [gate, result] of Object.entries(this.results.gates)) {
+        if (!result.passed) {
+          console.log(`\n   ${gate}:`);
+          for (const error of result.errors) {
+            console.log(`     - ${error}`);
+          }
+        }
+      }
+    }
+
+    console.log('');
+  }
+}
+
+// CLI entry point
+async function main() {
+  const args = process.argv.slice(2);
+
+  const getArg = (name) => {
+    const index = args.indexOf(`--${name}`);
+    return index >= 0 ? args[index + 1] : null;
+  };
+
+  const phase = parseInt(getArg('phase') || '1');
+  const configPath = getArg('config');
+  const progressPath = getArg('progress');
+  const verbose = args.includes('--verbose') || args.includes('-v');
+
+  const validator = new PhaseValidator({
+    phase,
+    configPath,
+    progressPath,
+    verbose,
+  });
+
+  const results = await validator.validate();
+  process.exit(results.passed ? 0 : 1);
+}
+
+// Export for use as module
+export { PhaseValidator, GATES };
+
+main().catch(console.error);

package/templates/scripts/poll-deployment-status.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * Poll Deployment Status
+ *
+ * Polls deployment status until complete or timeout.
+ * Supports Railway, Cloudflare, Vercel, and custom endpoints.
+ *
+ * Usage:
+ *   node poll-deployment-status.js --platform railway --deployment-id abc123
+ *   node poll-deployment-status.js --platform cloudflare --project-name my-project
+ *   node poll-deployment-status.js --url https://api.example.com/status
+ */
+
+const POLL_INTERVAL = 5000; // 5 seconds
+const DEFAULT_TIMEOUT = 300000; // 5 minutes
+
+class DeploymentPoller {
+  constructor(options) {
+    this.platform = options.platform;
+    this.deploymentId = options.deploymentId;
+    this.projectName = options.projectName;
+    this.projectId = options.projectId;
+    this.url = options.url;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+    this.verbose = options.verbose || false;
+    this.startTime = Date.now();
+  }
+
+  async poll() {
+    console.log(`\n🚀 Polling ${this.platform || 'custom'} deployment...`);
+    console.log(`   Timeout: ${this.timeout / 1000}s\n`);
+
+    let lastStatus = null;
+
+    while (Date.now() - this.startTime < this.timeout) {
+      try {
+        const status = await this.checkStatus();
+
+        if (status.status !== lastStatus) {
+          this.logStatus(status);
+          lastStatus = status.status;
+        } else if (this.verbose) {
+          process.stdout.write('.');
+        }
+
+        if (status.completed) {
+          return this.handleCompletion(status);
+        }
+
+        await this.sleep(POLL_INTERVAL);
+      } catch (error) {
+        console.error(`\n❌ Error polling: ${error.message}`);
+        if (this.verbose) console.error(error);
+        await this.sleep(POLL_INTERVAL);
+      }
+    }
+
+    console.error(`\n⏰ Timeout after ${this.timeout / 1000}s`);
+    return { success: false, reason: 'timeout' };
+  }
+
+  async checkStatus() {
+    switch (this.platform) {
+      case 'railway':
+        return this.checkRailway();
+      case 'cloudflare':
+        return this.checkCloudflare();
+      case 'vercel':
+        return this.checkVercel();
+      case 'custom':
+        return this.checkCustom();
+      default:
+        throw new Error(`Unknown platform: ${this.platform}`);
+    }
+  }
+
+  async checkRailway() {
+    const token = process.env.RAILWAY_API_TOKEN;
+    if (!token) throw new Error('RAILWAY_API_TOKEN not set');
+
+    const query = `
+      query GetDeployment($id: String!) {
+        deployment(id: $id) {
+          id
+          status
+          createdAt
+          staticUrl
+          meta
+        }
+      }
+    `;
+
+    const response = await fetch('https://backboard.railway.app/graphql/v2', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        query,
+        variables: { id: this.deploymentId },
+      }),
+    });
+
+    const data = await response.json();
+    if (data.errors) throw new Error(data.errors[0].message);
+
+    const deployment = data.data.deployment;
+    const status = deployment.status;
+
+    return {
+      status,
+      completed: ['SUCCESS', 'FAILED', 'CRASHED', 'REMOVED'].includes(status),
+      success: status === 'SUCCESS',
+      url: deployment.staticUrl,
+      details: deployment,
+    };
+  }
+
+  async checkCloudflare() {
+    const token = process.env.CLOUDFLARE_API_TOKEN;
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+    if (!token) throw new Error('CLOUDFLARE_API_TOKEN not set');
+
+    // Get latest deployment
+    const response = await fetch(
+      `https://api.cloudflare.com/client/v4/accounts/${accountId}/pages/projects/${this.projectName}/deployments`,
+      {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+
+    const data = await response.json();
+    if (!data.success) throw new Error(data.errors[0].message);
+
+    const deployment = data.result[0]; // Latest deployment
+    const status = deployment.latest_stage?.status || 'unknown';
+
+    return {
+      status,
+      completed: ['success', 'failure', 'canceled'].includes(status),
+      success: status === 'success',
+      url: deployment.url,
+      details: deployment,
+    };
+  }
+
+  async checkVercel() {
+    const token = process.env.VERCEL_TOKEN;
+    if (!token) throw new Error('VERCEL_TOKEN not set');
+
+    const response = await fetch(
+      `https://api.vercel.com/v13/deployments/${this.deploymentId}`,
+      {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+        },
+      }
+    );
+
+    const deployment = await response.json();
+    const status = deployment.readyState;
+
+    return {
+      status,
+      completed: ['READY', 'ERROR', 'CANCELED'].includes(status),
+      success: status === 'READY',
+      url: deployment.url,
+      details: deployment,
+    };
+  }
+
+  async checkCustom() {
+    const response = await fetch(this.url);
+    const data = await response.json();
+
+    return {
+      status: data.status || 'unknown',
+      completed: data.completed || false,
+      success: data.success || data.status === 'success',
+      url: data.url,
+      details: data,
+    };
+  }
+
+  logStatus(status) {
+    const elapsed = Math.round((Date.now() - this.startTime) / 1000);
+    const icon = status.success ? '✅' :
+                 status.completed ? '❌' : '🔄';
+    console.log(`${icon} [${elapsed}s] Status: ${status.status}`);
+  }
+
+  handleCompletion(status) {
+    console.log('\n' + '='.repeat(50));
+    if (status.success) {
+      console.log('✅ Deployment completed successfully!');
+      if (status.url) {
+        console.log(`🔗 URL: ${status.url}`);
+      }
+    } else {
+      console.log('❌ Deployment failed');
+      if (this.verbose && status.details) {
+        console.log('Details:', JSON.stringify(status.details, null, 2));
+      }
+    }
+    console.log('='.repeat(50) + '\n');
+
+    return {
+      success: status.success,
+      status: status.status,
+      url: status.url,
+      duration: Date.now() - this.startTime,
+    };
+  }
+
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+// CLI entry point
+async function main() {
+  const args = process.argv.slice(2);
+
+  const getArg = (name) => {
+    const index = args.indexOf(`--${name}`);
+    return index >= 0 ? args[index + 1] : null;
+  };
+
+  const hasFlag = (name) => args.includes(`--${name}`);
+
+  const options = {
+    platform: getArg('platform') || 'railway',
+    deploymentId: getArg('deployment-id'),
+    projectName: getArg('project-name'),
+    projectId: getArg('project-id'),
+    url: getArg('url'),
+    timeout: parseInt(getArg('timeout') || '300') * 1000,
+    verbose: hasFlag('verbose') || hasFlag('v'),
+  };
+
+  if (options.platform !== 'custom' && !options.deploymentId && !options.projectName) {
+    console.error('Usage: node poll-deployment-status.js --platform <railway|cloudflare|vercel|custom>');
+    console.error('  --deployment-id <id>   Deployment ID (Railway, Vercel)');
+    console.error('  --project-name <name>  Project name (Cloudflare)');
+    console.error('  --timeout <seconds>    Timeout in seconds (default: 300)');
+    console.error('  --verbose              Show detailed output');
+    console.error('  --url <url>            Custom status endpoint');
+    process.exit(1);
+  }
+
+  const poller = new DeploymentPoller(options);
+  const result = await poller.poll();
+  process.exit(result.success ? 0 : 1);
+}
+
+main().catch(console.error);