@paths.design/caws-cli 7.0.2 → 7.0.3

package/dist/templates/codemod/README.md

@@ -0,0 +1 @@
+# Codemod Scripts

package/dist/templates/codemod/test.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * Template Codemod for CAWS Framework
+ * Automated code transformations for refactoring
+ * @author CAWS Framework
+ */
+
+const tsMorph = require('ts-morph');
+
+function applyCodemod(dryRun = true) {
+  console.log('🔧 Applying codemod transformations...');
+
+  const project = new tsMorph.Project();
+
+  // Load all TypeScript source files
+  const sourceFiles = project.addSourceFilesAtPaths('src/**/*.ts');
+
+  if (sourceFiles.length === 0) {
+    console.log('⚠️  No TypeScript source files found in src/ directory');
+    return { filesProcessed: 0, changesApplied: 0 };
+  }
+
+  console.log(`📁 Processing ${sourceFiles.length} source files`);
+  let totalChanges = 0;
+
+  for (const sourceFile of sourceFiles) {
+    const filePath = sourceFile.getFilePath();
+    console.log(`Processing: ${filePath}`);
+
+    let fileChanges = 0;
+
+    // Example transformations - customize these for your specific needs:
+
+    // 1. Add JSDoc to exported functions without documentation
+    const exportedFunctions = sourceFile
+      .getFunctions()
+      .filter((func) => func.isExported && !func.getJsDocs().length);
+
+    for (const func of exportedFunctions) {
+      func.addJsDoc({
+        description: `Handles ${func.getName()} operations`,
+        tags: [
+          { tagName: 'param', text: 'options - Configuration options' },
+          { tagName: 'returns', text: 'Result of the operation' },
+        ],
+      });
+      fileChanges++;
+    }
+
+    // 2. Add type annotations to untyped parameters (example)
+    // const untypedParams = sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.Parameter)
+    //   .filter(param => !param.getTypeNode());
+    // Add your transformation logic here...
+
+    if (fileChanges > 0) {
+      console.log(`  ✅ Applied ${fileChanges} transformations`);
+      totalChanges += fileChanges;
+    }
+  }
+
+  console.log(`📊 Codemod complete: ${totalChanges} total transformations`);
+
+  if (!dryRun) {
+    console.log('💾 Saving changes...');
+    project.saveSync();
+    console.log('✅ All changes saved successfully');
+  } else {
+    console.log('🔍 Dry run - no files were modified');
+  }
+
+  return {
+    filesProcessed: sourceFiles.length,
+    changesApplied: totalChanges,
+  };
+}
+
+// CLI interface
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const dryRun = !args.includes('--apply');
+
+  try {
+    const result = applyCodemod(dryRun);
+    console.log('✅ Codemod execution completed');
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Codemod execution failed:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { applyCodemod };

package/dist/templates/docs/README.md

@@ -0,0 +1,150 @@
+# CAWS Project Documentation
+
+## Overview
+This project is built with the **Coding Agent Workflow System (CAWS)** - an engineering-grade framework that ensures quality, reliability, and maintainability in AI-assisted development.
+
+## Key Features
+- 🔒 **Quality Gates**: Automated validation of scope, budget, and standards
+- 🧪 **Comprehensive Testing**: Unit, contract, integration, and mutation testing
+- 📊 **Observability**: Structured logging, metrics, and tracing
+- 🔄 **Rollback Ready**: Feature flags and migration support
+- 📦 **Provenance Tracking**: SBOM and SLSA attestation generation
+
+## Getting Started
+
+### 1. Project Setup
+The project is already scaffolded with CAWS. Review and customize:
+- `.caws/working-spec.yaml` - Project specification and requirements
+- `.caws/policy/tier-policy.json` - Risk tier definitions
+- `.github/workflows/caws.yml` - CI/CD quality gates
+
+### 2. Development Workflow
+1. **Plan**: Update working spec with requirements and scope
+2. **Implement**: Follow agent conduct rules and mode constraints
+3. **Verify**: Run tests and quality gates locally
+4. **Document**: Update documentation and generate provenance
+
+### 3. Quality Assurance
+- Run `npm run test` for all tests
+- Check trust score with CAWS tools
+- Validate against working specification
+- Ensure rollback capabilities
+
+## Architecture
+
+### Directory Structure
+```
+src/                    # Source code
+├── core/              # Core business logic
+├── api/               # API endpoints
+├── models/            # Data models
+└── utils/             # Utilities
+
+tests/                 # Test suites
+├── unit/             # Unit tests
+├── contract/         # Contract tests
+├── integration/      # Integration tests
+└── e2e/              # End-to-end tests
+
+apps/tools/caws/       # CAWS utilities
+└── prompt-lint.js    # Prompt validation
+└── attest.js         # SBOM/attestation generation
+```
+
+### Key Patterns
+- **Dependency Injection**: For testability and determinism
+- **Interface Segregation**: Clean boundaries and contracts
+- **Observability**: Structured logging and metrics
+- **Property Testing**: Edge cases and invariants
+
+## Development Guidelines
+
+### Agent Conduct Rules
+1. **Spec Adherence**: Stay within declared scope and mode
+2. **Determinism**: Inject time, UUID, and random dependencies
+3. **Comprehensive Testing**: Unit + property + integration tests
+4. **Observability**: Log, metric, and trace key operations
+5. **Rollback Ready**: Feature flags and migration support
+
+### Code Quality
+- **Type Safety**: Full TypeScript coverage
+- **Test Coverage**: 80%+ branch coverage, 50%+ mutation score
+- **Performance**: API p95 < 250ms, accessibility compliance
+- **Security**: Input validation, rate limiting, secret scanning
+
+## Deployment
+
+### CI/CD Pipeline
+The project includes automated quality gates:
+- Static analysis and security scanning
+- Unit and integration testing
+- Performance and accessibility validation
+- Provenance and attestation generation
+
+### Environment Setup
+1. Configure environment variables
+2. Set up monitoring and alerting
+3. Establish rollback procedures
+4. Document operational runbooks
+
+## Monitoring & Observability
+
+### Metrics
+- Request latency and throughput
+- Error rates and types
+- Resource utilization
+- Business metrics
+
+### Logging
+- Structured logs with correlation IDs
+- Error tracking and alerting
+- Performance monitoring
+- Security event logging
+
+### Tracing
+- Distributed request tracing
+- Performance profiling
+- Dependency analysis
+- Root cause identification
+
+## Troubleshooting
+
+### Common Issues
+1. **Trust Score Low**: Check test coverage and quality gates
+2. **Scope Violations**: Ensure changes align with working spec
+3. **Budget Exceeded**: Review change size and complexity
+4. **Flaky Tests**: Use property testing and proper mocking
+
+### Support
+- Check `agents.md` for comprehensive documentation
+- Review CI/CD logs for quality gate failures
+- Use CAWS tools for validation and debugging
+- Follow agent conduct rules for collaboration
+
+## Contributing
+
+### Development Process
+1. Update working specification
+2. Create comprehensive tests
+3. Implement with quality gates
+4. Generate provenance artifacts
+5. Document changes thoroughly
+
+### Code Review
+- Review against working specification
+- Check trust score and quality gates
+- Validate observability and rollback
+- Ensure documentation completeness
+
+## Resources
+
+- **[CAWS Framework](agents.md)**: Complete system documentation
+- **[Working Specification](.caws/working-spec.yaml)**: Project requirements
+- **[Quality Gates](.github/workflows/caws.yml)**: CI/CD pipeline
+- **[Tools](apps/tools/caws/)**: Development utilities
+
+---
+
+**Maintainer**: @darianrosebrook
+**Framework**: CAWS v1.0
+**Updated**: $(date)

package/dist/templates/scripts/quality-gates/check-god-objects.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+/**
+ * God Object Detector
+ * 
+ * Checks for god objects (large files) in staged files only.
+ * This script is automatically generated by CAWS scaffold.
+ * 
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Configuration
+const CONFIG = {
+  godObjectThresholds: {
+    warning: 1750,
+    critical: 2000,
+  },
+};
+
+// Collect staged Rust files only
+function collectStagedRustFiles() {
+  try {
+    // Get staged files
+    const stagedFiles = execSync("git diff --cached --name-only", {
+      encoding: "utf8",
+    })
+      .trim()
+      .split("\n")
+      .filter((file) => file.trim() !== "");
+
+    // Filter for Rust files
+    const rustFiles = stagedFiles.filter((file) => file.endsWith(".rs"));
+
+    // Convert to absolute paths
+    const RUST_FILES = [];
+    for (const file of rustFiles) {
+      const fullPath = path.resolve(file);
+      if (fs.existsSync(fullPath)) {
+        RUST_FILES.push(fullPath);
+      }
+    }
+
+    console.log(`📁 Found ${rustFiles.length} staged Rust files to check`);
+    return RUST_FILES;
+  } catch (error) {
+    console.warn(`⚠️  Could not get staged files: ${error.message}`);
+    return [];
+  }
+}
+
+// Check for god objects
+function checkGodObjects() {
+  const RUST_FILES = collectStagedRustFiles();
+  
+  if (RUST_FILES.length === 0) {
+    console.log("✅ No staged Rust files to check for god objects");
+    return { violations: [], warnings: [] };
+  }
+
+  const violations = [];
+  const warnings = [];
+
+  for (const filePath of RUST_FILES) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lineCount = content.split('\n').length;
+      const relativePath = path.relative(process.cwd(), filePath);
+
+      if (lineCount >= CONFIG.godObjectThresholds.critical) {
+        violations.push({
+          file: relativePath,
+          lines: lineCount,
+          message: `CRITICAL: ${lineCount} LOC exceeds god object threshold (${CONFIG.godObjectThresholds.critical}+ LOC)`
+        });
+      } else if (lineCount >= CONFIG.godObjectThresholds.warning) {
+        warnings.push({
+          file: relativePath,
+          lines: lineCount,
+          message: `WARNING: ${lineCount} LOC approaches god object territory (${CONFIG.godObjectThresholds.warning}+ LOC)`
+        });
+      }
+    } catch (error) {
+      console.warn(`⚠️  Could not analyze ${filePath}: ${error.message}`);
+    }
+  }
+
+  return { violations, warnings };
+}
+
+// Check for god object regression
+function checkGodObjectRegression() {
+  const RUST_FILES = collectStagedRustFiles();
+  
+  if (RUST_FILES.length === 0) {
+    return { regression: false };
+  }
+
+  // This is a simplified check - in a real implementation,
+  // you might want to compare against previous commits
+  const results = checkGodObjects();
+  
+  return {
+    regression: results.violations.length > 0,
+    violations: results.violations,
+    warnings: results.warnings
+  };
+}
+
+// Main execution
+function main() {
+  console.log("🏗️  Checking god objects...");
+  
+  const results = checkGodObjects();
+  
+  if (results.violations.length > 0) {
+    console.log("   ❌ God object violations detected:");
+    results.violations.forEach(violation => {
+      console.log(`      ${violation.file}: ${violation.message}`);
+    });
+    process.exit(1);
+  } else {
+    console.log("   ✅ No blocking god object violations");
+  }
+  
+  if (results.warnings.length > 0) {
+    console.log("   ⚠️  God object warnings:");
+    results.warnings.forEach(warning => {
+      console.log(`      ${warning.file}: ${warning.message}`);
+    });
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  checkGodObjects,
+  checkGodObjectRegression,
+  collectStagedRustFiles,
+};

package/dist/templates/scripts/quality-gates/run-quality-gates.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+/**
+ * Quality Gates Runner
+ * 
+ * Runs comprehensive quality gates on staged files only.
+ * This script is automatically generated by CAWS scaffold.
+ * 
+ * @author @darianrosebrook
+ */
+
+const { runQualityGates } = require('@paths.design/caws-cli/src/utils/quality-gates');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const options = {
+  languages: ['rust'],
+  checkTodos: true,
+  checkGodObjects: true,
+  ci: args.includes('--ci') || args.includes('--ci-mode')
+};
+
+// Extract languages from arguments
+const langIndex = args.indexOf('--languages');
+if (langIndex !== -1 && args[langIndex + 1]) {
+  options.languages = args[langIndex + 1].split(',').map(lang => lang.trim());
+}
+
+// Check for disable flags
+if (args.includes('--no-todos')) {
+  options.checkTodos = false;
+}
+
+if (args.includes('--no-god-objects')) {
+  options.checkGodObjects = false;
+}
+
+// Run quality gates
+try {
+  const results = runQualityGates(options);
+  
+  if (!results.passed && options.ci) {
+    process.exit(1);
+  }
+} catch (error) {
+  console.error(`❌ Quality gates failed: ${error.message}`);
+  if (options.ci) {
+    process.exit(1);
+  }
+}