@paths.design/caws-cli 3.0.0 → 3.1.1

package/dist/utils/finalization.js

@@ -0,0 +1,229 @@
+/**
+ * @fileoverview Project Finalization Utilities
+ * Functions for finalizing CAWS project setup
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+// CLI version from package.json
+const CLI_VERSION = require('../../package.json').version;
+
+// Import scaffold utilities
+const { scaffoldCursorHooks } = require('../scaffold/cursor-hooks');
+
+// Dependencies injected via setFinalizationDependencies()
+let languageSupport = null;
+let loadProvenanceTools = null;
+
+/**
+ * Set dependencies for finalization utilities
+ * @param {Object} deps - Dependencies object
+ */
+function setFinalizationDependencies(deps) {
+  languageSupport = deps.languageSupport;
+  loadProvenanceTools = deps.loadProvenanceTools;
+}
+
+/**
+ * Generate provenance manifest and git initialization (for both modes)
+ * @param {string} projectName - Project name
+ * @param {Object} options - Command options
+ * @param {Object} answers - User answers
+ */
+async function finalizeProject(projectName, options, answers) {
+  try {
+    // Detect and configure language support
+    if (languageSupport) {
+      console.log(chalk.cyan('🔍 Detecting project language...'));
+      const detectedLanguage = languageSupport.detectProjectLanguage();
+
+      if (detectedLanguage !== 'unknown') {
+        console.log(chalk.green(`✅ Detected language: ${detectedLanguage}`));
+
+        // Generate language-specific configuration
+        try {
+          const langConfig = languageSupport.generateLanguageConfig(
+            detectedLanguage,
+            '.caws/language-config.json'
+          );
+
+          console.log(chalk.green('✅ Generated language-specific configuration'));
+          console.log(`   Language: ${langConfig.name}`);
+          console.log(`   Tier: ${langConfig.tier}`);
+          console.log(
+            `   Thresholds: Branch ≥${langConfig.thresholds.min_branch * 100}%, Mutation ≥${langConfig.thresholds.min_mutation * 100}%`
+          );
+        } catch (langError) {
+          console.warn(chalk.yellow('⚠️  Could not generate language config:'), langError.message);
+        }
+      } else {
+        console.log(
+          chalk.blue('ℹ️  Could not detect project language - using default configuration')
+        );
+      }
+    }
+
+    // Setup Cursor hooks if enabled
+    if (answers && answers.enableCursorHooks) {
+      console.log(chalk.cyan('📌 Setting up Cursor hooks...'));
+      await scaffoldCursorHooks(
+        process.cwd(),
+        answers.cursorHookLevels || ['safety', 'quality', 'scope', 'audit']
+      );
+    }
+
+    // Generate provenance manifest
+    console.log(chalk.cyan('📦 Generating provenance manifest...'));
+
+    const provenanceData = {
+      agent: 'caws-cli',
+      model: 'cli-interactive',
+      modelHash: CLI_VERSION,
+      toolAllowlist: [
+        'node',
+        'npm',
+        'git',
+        'fs-extra',
+        'inquirer',
+        'commander',
+        'js-yaml',
+        'ajv',
+        'chalk',
+      ],
+      prompts: Object.keys(answers),
+      commit: null, // Will be set after git init
+      artifacts: ['.caws/working-spec.yaml'],
+      results: {
+        project_id: answers.projectId,
+        project_title: answers.projectTitle,
+        risk_tier: answers.riskTier,
+        mode: answers.projectMode,
+        change_budget: {
+          max_files: answers.maxFiles,
+          max_loc: answers.maxLoc,
+        },
+      },
+      approvals: [],
+    };
+
+    // Generate provenance if tools are available
+    const tools = loadProvenanceTools && loadProvenanceTools();
+    if (
+      tools &&
+      typeof tools.generateProvenance === 'function' &&
+      typeof tools.saveProvenance === 'function'
+    ) {
+      const provenance = tools.generateProvenance(provenanceData);
+      await tools.saveProvenance(provenance, '.agent/provenance.json');
+      console.log(chalk.green('✅ Provenance manifest generated'));
+    } else {
+      console.log(
+        chalk.yellow('⚠️  Provenance tools not available - skipping manifest generation')
+      );
+    }
+
+    // Initialize git repository
+    if (options.git) {
+      try {
+        console.log(chalk.cyan('🔧 Initializing git repository...'));
+
+        // Check if git is available
+        try {
+          require('child_process').execSync('git --version', { stdio: 'ignore' });
+        } catch (error) {
+          console.warn(chalk.yellow('⚠️  Git not found. Skipping git initialization.'));
+          console.warn(chalk.blue('💡 Install git to enable automatic repository setup.'));
+          return;
+        }
+
+        // Configure git author information
+        const gitConfig = answers.git_config || {};
+        const authorName = process.env.GIT_AUTHOR_NAME || gitConfig.author_name;
+        const authorEmail = process.env.GIT_AUTHOR_EMAIL || gitConfig.author_email;
+
+        if (authorName && authorEmail) {
+          require('child_process').execSync(`git config user.name "${authorName}"`, {
+            stdio: 'inherit',
+          });
+          require('child_process').execSync(`git config user.email "${authorEmail}"`, {
+            stdio: 'inherit',
+          });
+          console.log(chalk.green(`✅ Git configured: ${authorName} <${authorEmail}>`));
+        }
+
+        require('child_process').execSync('git init', { stdio: 'inherit' });
+        require('child_process').execSync('git add .', { stdio: 'inherit' });
+        require('child_process').execSync('git commit -m "Initial CAWS project setup"', {
+          stdio: 'inherit',
+        });
+        console.log(chalk.green('✅ Git repository initialized'));
+
+        // Update provenance with commit hash
+        const commitHash = require('child_process')
+          .execSync('git rev-parse HEAD', { encoding: 'utf8' })
+          .trim();
+        const currentProvenance = JSON.parse(fs.readFileSync('.agent/provenance.json', 'utf8'));
+        currentProvenance.commit = commitHash;
+        currentProvenance.hash = require('crypto')
+          .createHash('sha256')
+          .update(JSON.stringify(currentProvenance, Object.keys(currentProvenance).sort()))
+          .digest('hex');
+        await fs.writeFile('.agent/provenance.json', JSON.stringify(currentProvenance, null, 2));
+
+        console.log(chalk.green('✅ Provenance updated with commit hash'));
+      } catch (error) {
+        console.warn(
+          chalk.yellow('⚠️  Failed to initialize git repository:'),
+          error?.message || String(error)
+        );
+        console.warn(chalk.blue('💡 You can initialize git manually later with:'));
+        console.warn("   git init && git add . && git commit -m 'Initial CAWS project setup'");
+      }
+    }
+  } catch (error) {
+    console.error(
+      chalk.red('❌ Error during project finalization:'),
+      error?.message || String(error)
+    );
+  }
+}
+
+/**
+ * Display success message after project initialization
+ */
+function continueToSuccess() {
+  const isCurrentDir =
+    process.cwd() ===
+    path.resolve(process.argv[3] === '.' ? process.cwd() : process.argv[3] || 'caws-project');
+
+  console.log(chalk.green('\n🎉 CAWS project initialized successfully!'));
+
+  if (isCurrentDir) {
+    console.log(
+      `📁 ${chalk.cyan('Initialized in current directory')}: ${path.resolve(process.cwd())}`
+    );
+    console.log(chalk.gray('   (CAWS files added to your existing project)'));
+  } else {
+    console.log(`📁 ${chalk.cyan('Project location')}: ${path.resolve(process.cwd())}`);
+    console.log(chalk.gray('   (New subdirectory created with CAWS structure)'));
+  }
+
+  console.log(chalk.bold('\nNext steps:'));
+  console.log('1. Customize .caws/working-spec.yaml');
+  console.log('2. Review added CAWS tools and documentation');
+  if (!isCurrentDir) {
+    console.log('3. Move CAWS files to your main project if needed');
+  }
+  console.log('4. npm install (if using Node.js)');
+  console.log('5. Set up your CI/CD pipeline');
+  console.log(chalk.blue('\nFor help: caws --help'));
+}
+
+module.exports = {
+  finalizeProject,
+  continueToSuccess,
+  setFinalizationDependencies,
+};

package/dist/utils/project-analysis.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Detect project type from existing files and structure
+ * @param {string} cwd - Current working directory
+ * @returns {string} Project type
+ */
+export function detectProjectType(cwd?: string): string;
+/**
+ * Detect if current directory appears to be a project that should be initialized directly
+ * @param {string} projectName - Project name from command line
+ * @param {string} currentDir - Current directory path
+ * @returns {boolean} Whether to init in current directory
+ */
+export function shouldInitInCurrentDirectory(projectName: string, currentDir: string): boolean;
+//# sourceMappingURL=project-analysis.d.ts.map

package/dist/utils/project-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-analysis.d.ts","sourceRoot":"","sources":["../../src/utils/project-analysis.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,wCAHW,MAAM,GACJ,MAAM,CAmDlB;AAED;;;;;GAKG;AACH,0DAJW,MAAM,cACN,MAAM,GACJ,OAAO,CA8BnB"}

package/dist/utils/project-analysis.js

@@ -0,0 +1,105 @@
+/**
+ * @fileoverview Project Analysis Utilities
+ * Functions for analyzing project types and structure
+ * @author @darianrosebrook
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Detect project type from existing files and structure
+ * @param {string} cwd - Current working directory
+ * @returns {string} Project type
+ */
+function detectProjectType(cwd = process.cwd()) {
+  const files = fs.readdirSync(cwd);
+
+  // Check for various project indicators
+  const hasPackageJson = files.includes('package.json');
+  const hasPnpm = files.includes('pnpm-workspace.yaml');
+  const hasYarn = files.includes('yarn.lock');
+
+  let packageJson = {};
+  if (hasPackageJson) {
+    try {
+      packageJson = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  // VS Code Extension detection
+  const isVscodeExtension =
+    packageJson.engines?.vscode ||
+    packageJson.contributes ||
+    packageJson.activationEvents ||
+    packageJson.main?.includes('extension.js');
+
+  // Monorepo detection
+  const isMonorepo = hasPnpm || hasYarn || files.includes('packages') || files.includes('apps');
+
+  // Library detection
+  const isLibrary = packageJson.main || packageJson.module || packageJson.exports;
+
+  // CLI detection
+  const isCli = packageJson.bin || packageJson.name?.startsWith('@') === false;
+
+  // API detection
+  const isApi =
+    packageJson.scripts?.start ||
+    packageJson.dependencies?.express ||
+    packageJson.dependencies?.fastify ||
+    packageJson.dependencies?.['@types/express'];
+
+  // Determine primary type
+  if (isVscodeExtension) return 'extension';
+  if (isMonorepo) return 'monorepo';
+  if (isApi) return 'api';
+  if (isLibrary) return 'library';
+  if (isCli) return 'cli';
+
+  // Default fallback
+  return 'application';
+}
+
+/**
+ * Detect if current directory appears to be a project that should be initialized directly
+ * @param {string} projectName - Project name from command line
+ * @param {string} currentDir - Current directory path
+ * @returns {boolean} Whether to init in current directory
+ */
+function shouldInitInCurrentDirectory(projectName, currentDir) {
+  // If explicitly '.', always init in current directory
+  if (projectName === '.') return true;
+
+  // Check for common project indicators
+  const projectIndicators = [
+    'package.json',
+    'tsconfig.json',
+    'jest.config.js',
+    'eslint.config.js',
+    'README.md',
+    'src/',
+    'lib/',
+    'app/',
+    'packages/',
+    '.git/',
+    'node_modules/', // Even if empty, suggests intent to be a project
+  ];
+
+  const files = fs.readdirSync(currentDir);
+  const hasProjectIndicators = projectIndicators.some((indicator) => {
+    if (indicator.endsWith('/')) {
+      return files.includes(indicator.slice(0, -1));
+    }
+    return files.includes(indicator);
+  });
+
+  return hasProjectIndicators;
+}
+
+module.exports = {
+  detectProjectType,
+  shouldInitInCurrentDirectory,
+};

package/dist/validation/spec-validation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Basic validation of working spec
+ * @param {Object} spec - Working spec object
+ * @param {Object} options - Validation options
+ * @returns {Object} Validation result
+ */
+export function validateWorkingSpec(spec: any, _options?: {}): any;
+/**
+ * Enhanced validation with suggestions and auto-fix
+ * @param {Object} spec - Working spec object
+ * @param {Object} options - Validation options
+ * @returns {Object} Enhanced validation result
+ */
+export function validateWorkingSpecWithSuggestions(spec: any, options?: any): any;
+/**
+ * Get suggestion for a missing field
+ * @param {string} field - Field name
+ * @param {Object} _spec - Spec object (for context)
+ * @returns {string} Suggestion text
+ */
+export function getFieldSuggestion(field: string, _spec: any): string;
+/**
+ * Check if a field can be auto-fixed
+ * @param {string} field - Field name
+ * @param {Object} _spec - Spec object (for context)
+ * @returns {boolean} Whether field can be auto-fixed
+ */
+export function canAutoFixField(field: string, _spec: any): boolean;
+//# sourceMappingURL=spec-validation.d.ts.map

package/dist/validation/spec-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-validation.d.ts","sourceRoot":"","sources":["../../src/validation/spec-validation.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,mEA8HC;AAED;;;;;GAKG;AACH,kFAyLC;AAED;;;;;GAKG;AACH,0CAJW,MAAM,eAEJ,MAAM,CAkBlB;AAED;;;;;GAKG;AACH,uCAJW,MAAM,eAEJ,OAAO,CAKnB"}