@paths.design/caws-cli 7.0.2 → 8.0.0

package/templates/apps/tools/caws/gates.ts

@@ -1,271 +0,0 @@
-#!/usr/bin/env tsx
-
-/**
- * CAWS Gates Tool - Enhanced Implementation
- * CLI wrapper for CawsGateChecker with tier policies
- *
- * @author @darianrosebrook
- */
-
-import { CawsGateChecker } from './shared/gate-checker.js';
-import { CawsConfigManager } from './shared/config-manager.js';
-
-// Tier policies for quality gates
-const TIER_POLICIES = {
-  1: {
-    branch_coverage: 0.9,
-    mutation_score: 0.7,
-    max_files: 40,
-    max_loc: 1500,
-    trust_score: 85,
-  },
-  2: {
-    branch_coverage: 0.8,
-    mutation_score: 0.5,
-    max_files: 25,
-    max_loc: 1000,
-    trust_score: 82,
-  },
-  3: {
-    branch_coverage: 0.7,
-    mutation_score: 0.3,
-    max_files: 15,
-    max_loc: 500,
-    trust_score: 75,
-  },
-};
-
-class GatesCLI {
-  private gateChecker: CawsGateChecker;
-  private configManager: CawsConfigManager;
-
-  constructor() {
-    this.gateChecker = new CawsGateChecker();
-    this.configManager = new CawsConfigManager();
-  }
-
-  /**
-   * Show tier policy
-   */
-  showTierPolicy(tier: number = 1): void {
-    const policy = TIER_POLICIES[tier as keyof typeof TIER_POLICIES];
-    if (!policy) {
-      console.error(`❌ Unknown tier: ${tier}`);
-      process.exit(1);
-    }
-
-    console.log(`📋 Tier ${tier} Policy:`);
-    console.log(`Branch Coverage: ≥${policy.branch_coverage * 100}%`);
-    console.log(`Mutation Score: ≥${policy.mutation_score * 100}%`);
-    console.log(`Max Files: ${policy.max_files}`);
-    console.log(`Max LOC: ${policy.max_loc}`);
-    console.log(`Trust Score: ≥${policy.trust_score}`);
-    console.log('Requires Contracts: true');
-    console.log('Manual Review: Required');
-  }
-
-  /**
-   * Enforce coverage gate using CawsGateChecker
-   */
-  async enforceCoverageGate(tier: number = 2): Promise<boolean> {
-    try {
-      const policy = TIER_POLICIES[tier as keyof typeof TIER_POLICIES];
-      const result = await this.gateChecker.checkCoverage({
-        tier,
-        workingDirectory: process.cwd(),
-      });
-
-      if (result.passed) {
-        console.log(
-          `✅ Coverage gate passed: ${(result.score * 100).toFixed(1)}% ≥ ${policy.branch_coverage * 100}%`
-        );
-        return true;
-      } else {
-        console.log(
-          `❌ Coverage gate failed: ${(result.score * 100).toFixed(1)}% < ${policy.branch_coverage * 100}%`
-        );
-        if (result.errors && result.errors.length > 0) {
-          result.errors.forEach((error) => console.error(`  - ${error}`));
-        }
-        if (result.details?.searched_paths) {
-          console.error(`  Searched paths: ${result.details.searched_paths.join(', ')}`);
-        }
-        if (result.details?.run_command) {
-          console.error(`  Run: ${result.details.run_command}`);
-        }
-        if (result.details?.waiver_available) {
-          console.error(`  💡 ${result.details.waiver_suggestion}`);
-          console.error(`     ${result.details.waiver_command}`);
-        }
-        return false;
-      }
-    } catch (error) {
-      console.error(`❌ Coverage gate check failed: ${error}`);
-      return false;
-    }
-  }
-
-  /**
-   * Enforce mutation gate using CawsGateChecker
-   */
-  async enforceMutationGate(tier: number = 2): Promise<boolean> {
-    try {
-      const policy = TIER_POLICIES[tier as keyof typeof TIER_POLICIES];
-      const result = await this.gateChecker.checkMutation({
-        tier,
-        workingDirectory: process.cwd(),
-      });
-
-      if (result.passed) {
-        console.log(
-          `✅ Mutation gate passed: ${(result.score * 100).toFixed(1)}% ≥ ${policy.mutation_score * 100}%`
-        );
-        return true;
-      } else {
-        console.log(
-          `❌ Mutation gate failed: ${(result.score * 100).toFixed(1)}% < ${policy.mutation_score * 100}%`
-        );
-        if (result.errors && result.errors.length > 0) {
-          result.errors.forEach((error) => console.error(`  - ${error}`));
-        }
-        if (result.details?.searched_paths) {
-          console.error(`  Searched paths: ${result.details.searched_paths.join(', ')}`);
-        }
-        if (result.details?.run_command) {
-          console.error(`  Run: ${result.details.run_command}`);
-        }
-        if (result.details?.waiver_available) {
-          console.error(`  💡 ${result.details.waiver_suggestion}`);
-          console.error(
-            `     caws waivers create --title="Mutation waiver" --reason=emergency_hotfix --gates=mutation`
-          );
-        }
-        return false;
-      }
-    } catch (error) {
-      console.error(`❌ Mutation gate check failed: ${error}`);
-      return false;
-    }
-  }
-
-  /**
-   * Enforce contract gate using CawsGateChecker
-   */
-  async enforceContractGate(tier: number = 2): Promise<boolean> {
-    try {
-      const result = await this.gateChecker.checkContracts({
-        tier,
-        workingDirectory: process.cwd(),
-      });
-
-      if (result.passed) {
-        console.log('✅ Contract gate passed');
-        return true;
-      } else {
-        console.log('❌ Contract gate failed');
-        if (result.errors && result.errors.length > 0) {
-          result.errors.forEach((error) => console.error(`  - ${error}`));
-        }
-        if (result.details?.searched_paths) {
-          console.error(`  Searched paths: ${result.details.searched_paths.join(', ')}`);
-        }
-        if (result.details?.example_command) {
-          console.error(`  Example: ${result.details.example_command}`);
-        }
-        console.error(
-          `  💡 If contracts are not required for this tier, consider creating a waiver`
-        );
-        console.error(
-          `     caws waivers create --title="Contract waiver" --reason=experimental_feature --gates=contracts`
-        );
-        return false;
-      }
-    } catch (error) {
-      console.error(`❌ Contract gate check failed: ${error}`);
-      return false;
-    }
-  }
-
-  /**
-   * Run all gates for a tier
-   */
-  async runAllGates(tier: number = 2): Promise<boolean> {
-    console.log(`\n🚪 Running all gates for Tier ${tier}...\n`);
-
-    const results = await Promise.all([
-      this.enforceCoverageGate(tier),
-      this.enforceMutationGate(tier),
-      this.enforceContractGate(tier),
-    ]);
-
-    const allPassed = results.every((r) => r);
-
-    console.log(`\n${'='.repeat(50)}`);
-    if (allPassed) {
-      console.log('✅ All gates passed!');
-    } else {
-      console.log('❌ Some gates failed');
-    }
-    console.log('='.repeat(50));
-
-    return allPassed;
-  }
-}
-
-// Main CLI handler
-if (import.meta.url === `file://${process.argv[1]}`) {
-  (async () => {
-    const command = process.argv[2];
-    const cli = new GatesCLI();
-
-    switch (command) {
-      case 'tier': {
-        const tier = parseInt(process.argv[3]) || 1;
-        cli.showTierPolicy(tier);
-        break;
-      }
-
-      case 'coverage': {
-        const tier = parseInt(process.argv[3]) || 2;
-        const passed = await cli.enforceCoverageGate(tier);
-        process.exit(passed ? 0 : 1);
-      }
-
-      case 'mutation': {
-        const tier = parseInt(process.argv[3]) || 2;
-        const passed = await cli.enforceMutationGate(tier);
-        process.exit(passed ? 0 : 1);
-      }
-
-      case 'contracts': {
-        const tier = parseInt(process.argv[3]) || 2;
-        const passed = await cli.enforceContractGate(tier);
-        process.exit(passed ? 0 : 1);
-      }
-
-      case 'all': {
-        const tier = parseInt(process.argv[3]) || 2;
-        const passed = await cli.runAllGates(tier);
-        process.exit(passed ? 0 : 1);
-      }
-
-      default:
-        console.log('CAWS Gates Tool - Quality Gate Enforcement');
-        console.log('');
-        console.log('Commands:');
-        console.log('  tier <tier>       - Show tier policy');
-        console.log('  coverage <tier>   - Enforce coverage gate');
-        console.log('  mutation <tier>   - Enforce mutation gate');
-        console.log('  contracts <tier>  - Enforce contract gate');
-        console.log('  all <tier>        - Run all gates for tier');
-        console.log('');
-        console.log('Examples:');
-        console.log('  gates.ts tier 1');
-        console.log('  gates.ts coverage 2');
-        console.log('  gates.ts all 2');
-        process.exit(1);
-    }
-  })();
-}
-
-export { GatesCLI };

package/templates/apps/tools/caws/language-adapters.ts

@@ -1,381 +0,0 @@
-#!/usr/bin/env tsx
-
-/**
- * CAWS Language Adapter Manager
- * Multi-language support for TypeScript, Python, Rust, Go, Java
- *
- * @author @darianrosebrook
- */
-
-import * as path from 'path';
-import { CawsBaseTool } from './shared/base-tool.js';
-import { TierPolicy, GateConfig } from './shared/types.js';
-
-interface LanguageAdapter {
-  language: string;
-  fileExtensions: string[];
-  tools: {
-    unitTest: { command: string; args: string[] };
-    coverage: { command: string; args: string[] };
-    mutationTest?: { command: string; args: string[] };
-    contractTest?: { command: string; args: string[] };
-    lint: { command: string; args: string[] };
-  };
-  tierAdjustments?: {
-    [tier: number]: Partial<TierPolicy>;
-  };
-  fallbacks?: {
-    mutation?: string; // What to do if mutation testing unavailable
-    contracts?: string;
-  };
-}
-
-export class LanguageAdapterManager extends CawsBaseTool {
-  private adapters: Map<string, LanguageAdapter> = new Map();
-
-  constructor() {
-    super();
-    this.initializeAdapters();
-  }
-
-  private initializeAdapters(): void {
-    // TypeScript/JavaScript adapter
-    this.adapters.set('typescript', {
-      language: 'typescript',
-      fileExtensions: ['.ts', '.tsx', '.js', '.jsx'],
-      tools: {
-        unitTest: { command: 'vitest', args: ['run'] },
-        coverage: { command: 'vitest', args: ['run', '--coverage'] },
-        mutationTest: { command: 'stryker', args: ['run'] },
-        contractTest: { command: 'pact', args: ['verify'] },
-        lint: { command: 'eslint', args: ['.'] },
-      },
-    });
-
-    // Python adapter
-    this.adapters.set('python', {
-      language: 'python',
-      fileExtensions: ['.py'],
-      tools: {
-        unitTest: { command: 'pytest', args: [] },
-        coverage: { command: 'pytest', args: ['--cov'] },
-        mutationTest: { command: 'mutmut', args: ['run'] },
-        contractTest: { command: 'schemathesis', args: ['run'] },
-        lint: { command: 'ruff', args: ['check', '.'] },
-      },
-      tierAdjustments: {
-        1: { min_mutation: 0.6 }, // Python mutation testing is less mature
-        2: { min_mutation: 0.4 },
-        3: { min_mutation: 0.25 },
-      },
-      fallbacks: {
-        mutation: 'If mutation testing unavailable, increase integration test coverage by 20%',
-        contracts: 'Use pytest with OpenAPI schema validation',
-      },
-    });
-
-    // Rust adapter
-    this.adapters.set('rust', {
-      language: 'rust',
-      fileExtensions: ['.rs'],
-      tools: {
-        unitTest: { command: 'cargo', args: ['test'] },
-        coverage: { command: 'cargo', args: ['tarpaulin', '--out', 'Json'] },
-        mutationTest: { command: 'cargo', args: ['mutants'] },
-        lint: { command: 'cargo', args: ['clippy', '--', '-D', 'warnings'] },
-      },
-      tierAdjustments: {
-        1: { min_mutation: 0.65 },
-        2: { min_mutation: 0.45 },
-        3: { min_mutation: 0.3 },
-      },
-    });
-
-    // Go adapter
-    this.adapters.set('go', {
-      language: 'go',
-      fileExtensions: ['.go'],
-      tools: {
-        unitTest: { command: 'go', args: ['test', './...'] },
-        coverage: {
-          command: 'go',
-          args: ['test', '-coverprofile=coverage.out', './...'],
-        },
-        lint: { command: 'golangci-lint', args: ['run'] },
-      },
-      fallbacks: {
-        mutation: 'Go lacks mature mutation testing - require 90% branch coverage instead',
-        contracts: 'Use go-swagger for API contract validation',
-      },
-    });
-
-    // Java adapter
-    this.adapters.set('java', {
-      language: 'java',
-      fileExtensions: ['.java'],
-      tools: {
-        unitTest: { command: 'mvn', args: ['test'] },
-        coverage: { command: 'mvn', args: ['jacoco:report'] },
-        mutationTest: {
-          command: 'mvn',
-          args: ['org.pitest:pitest-maven:mutationCoverage'],
-        },
-        contractTest: { command: 'mvn', args: ['pact:verify'] },
-        lint: { command: 'mvn', args: ['checkstyle:check'] },
-      },
-    });
-  }
-
-  /**
-   * Detect project language based on files present
-   */
-  detectLanguage(projectDir: string): string | null {
-    const indicators = [
-      { file: 'package.json', language: 'typescript' },
-      { file: 'tsconfig.json', language: 'typescript' },
-      { file: 'requirements.txt', language: 'python' },
-      { file: 'pyproject.toml', language: 'python' },
-      { file: 'Pipfile', language: 'python' },
-      { file: 'Cargo.toml', language: 'rust' },
-      { file: 'go.mod', language: 'go' },
-      { file: 'pom.xml', language: 'java' },
-      { file: 'build.gradle', language: 'java' },
-    ];
-
-    for (const indicator of indicators) {
-      const filePath = path.join(projectDir, indicator.file);
-      if (this.pathExists(filePath)) {
-        return indicator.language;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Get adapter for a specific language
-   */
-  getAdapter(language: string): LanguageAdapter | null {
-    return this.adapters.get(language.toLowerCase()) || null;
-  }
-
-  /**
-   * Get adjusted tier policy for a language
-   */
-  getAdjustedTierPolicy(language: string, tier: number): TierPolicy | null {
-    const adapter = this.getAdapter(language);
-    if (!adapter) return null;
-
-    const basePolicies: Record<number, TierPolicy> = {
-      1: {
-        min_branch: 0.9,
-        min_coverage: 0.9,
-        min_mutation: 0.7,
-        requires_contracts: true,
-        requires_manual_review: true,
-      },
-      2: {
-        min_branch: 0.8,
-        min_coverage: 0.8,
-        min_mutation: 0.5,
-        requires_contracts: true,
-      },
-      3: {
-        min_branch: 0.7,
-        min_coverage: 0.7,
-        min_mutation: 0.3,
-        requires_contracts: false,
-      },
-    };
-
-    const basePolicy = basePolicies[tier];
-    if (!basePolicy) return null;
-
-    // Apply language-specific adjustments
-    const adjustments = adapter.tierAdjustments?.[tier] || {};
-    return { ...basePolicy, ...adjustments };
-  }
-
-  /**
-   * Generate language-specific configuration
-   */
-  generateConfig(language: string): Record<string, any> | null {
-    const adapter = this.getAdapter(language);
-    if (!adapter) return null;
-
-    return {
-      language: adapter.language,
-      tools: adapter.tools,
-      gates: this.generateGateConfig(adapter),
-      tierAdjustments: adapter.tierAdjustments,
-      fallbacks: adapter.fallbacks,
-    };
-  }
-
-  private generateGateConfig(adapter: LanguageAdapter): Record<string, GateConfig> {
-    const gates: Record<string, GateConfig> = {
-      coverage: {
-        enabled: true,
-        threshold: 0.8,
-      },
-      mutation: {
-        enabled: !!adapter.tools.mutationTest,
-        threshold: 0.5,
-      },
-      contracts: {
-        enabled: !!adapter.tools.contractTest,
-        threshold: 1.0,
-      },
-    };
-
-    return gates;
-  }
-
-  /**
-   * List all available adapters
-   */
-  listAdapters(): Array<{
-    language: string;
-    hasMutation: boolean;
-    hasContracts: boolean;
-  }> {
-    return Array.from(this.adapters.values()).map((adapter) => ({
-      language: adapter.language,
-      hasMutation: !!adapter.tools.mutationTest,
-      hasContracts: !!adapter.tools.contractTest,
-    }));
-  }
-
-  /**
-   * Check if tools are available for a language
-   */
-  checkToolAvailability(language: string): {
-    language: string;
-    available: Record<string, boolean>;
-    missing: string[];
-  } {
-    const adapter = this.getAdapter(language);
-    if (!adapter) {
-      return { language, available: {}, missing: [] };
-    }
-
-    const available: Record<string, boolean> = {};
-    const missing: string[] = [];
-
-    const toolChecks = [
-      { name: 'unitTest', tool: adapter.tools.unitTest },
-      { name: 'coverage', tool: adapter.tools.coverage },
-      { name: 'mutationTest', tool: adapter.tools.mutationTest },
-      { name: 'contractTest', tool: adapter.tools.contractTest },
-      { name: 'lint', tool: adapter.tools.lint },
-    ];
-
-    for (const { name, tool } of toolChecks) {
-      if (tool) {
-        // Simple check - just verify command exists (would need proper implementation)
-        available[name] = true; // Placeholder
-      } else {
-        available[name] = false;
-        missing.push(name);
-      }
-    }
-
-    return { language, available, missing };
-  }
-}
-
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const command = process.argv[2];
-  const manager = new LanguageAdapterManager();
-
-  switch (command) {
-    case 'detect': {
-      const projectDir = process.argv[3] || process.cwd();
-      const language = manager.detectLanguage(projectDir);
-
-      if (language) {
-        console.log(`✅ Detected language: ${language}`);
-        const adapter = manager.getAdapter(language);
-        if (adapter) {
-          console.log(`\n📦 Available tools:`);
-          console.log(`  Unit tests: ${adapter.tools.unitTest.command}`);
-          console.log(`  Coverage: ${adapter.tools.coverage.command}`);
-          if (adapter.tools.mutationTest) {
-            console.log(`  Mutation: ${adapter.tools.mutationTest.command}`);
-          }
-          if (adapter.tools.contractTest) {
-            console.log(`  Contracts: ${adapter.tools.contractTest.command}`);
-          }
-          console.log(`  Lint: ${adapter.tools.lint.command}`);
-        }
-      } else {
-        console.log('❌ Could not detect language');
-        process.exit(1);
-      }
-      break;
-    }
-
-    case 'list': {
-      const adapters = manager.listAdapters();
-      console.log('Available Language Adapters:');
-      console.log('='.repeat(50));
-      adapters.forEach((adapter) => {
-        console.log(`\n📚 ${adapter.language}`);
-        console.log(`  Mutation testing: ${adapter.hasMutation ? '✅' : '❌'}`);
-        console.log(`  Contract testing: ${adapter.hasContracts ? '✅' : '❌'}`);
-      });
-      break;
-    }
-
-    case 'config': {
-      const language = process.argv[3];
-      if (!language) {
-        console.error('Usage: language-adapters config <language>');
-        process.exit(1);
-      }
-
-      const config = manager.generateConfig(language);
-      if (config) {
-        console.log(JSON.stringify(config, null, 2));
-      } else {
-        console.error(`❌ No adapter found for language: ${language}`);
-        process.exit(1);
-      }
-      break;
-    }
-
-    case 'tier': {
-      const language = process.argv[3];
-      const tier = parseInt(process.argv[4]);
-
-      if (!language || !tier) {
-        console.error('Usage: language-adapters tier <language> <tier>');
-        process.exit(1);
-      }
-
-      const policy = manager.getAdjustedTierPolicy(language, tier);
-      if (policy) {
-        console.log(`Tier ${tier} policy for ${language}:`);
-        console.log(JSON.stringify(policy, null, 2));
-      } else {
-        console.error(`❌ Could not get policy for ${language} tier ${tier}`);
-        process.exit(1);
-      }
-      break;
-    }
-
-    default:
-      console.log('CAWS Language Adapter Manager');
-      console.log('');
-      console.log('Usage:');
-      console.log('  language-adapters detect [dir]          - Detect project language');
-      console.log('  language-adapters list                  - List available adapters');
-      console.log('  language-adapters config <language>     - Generate config for language');
-      console.log('  language-adapters tier <language> <tier> - Get tier policy for language');
-      console.log('');
-      console.log('Supported Languages:');
-      console.log('  typescript, python, rust, go, java');
-      break;
-  }
-}