@paths.design/caws-cli 8.0.1 → 8.1.0

package/dist/commands/provenance.js

@@ -4,12 +4,43 @@
  * @author @darianrosebrook
  */
 
+/* global fetch */
+
 const fs = require('fs-extra');
 const path = require('path');
 const crypto = require('crypto');
 const yaml = require('js-yaml');
+const { execSync } = require('child_process');
 const { commandWrapper } = require('../utils/command-wrapper');
 
+/**
+ * Get quality gates status from saved report
+ * @returns {Object} Quality gates status
+ */
+function getQualityGatesStatus() {
+  const reportPath = path.join(process.cwd(), '.caws', 'quality-gates-report.json');
+
+  if (fs.existsSync(reportPath)) {
+    try {
+      const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+      return {
+        status: report.passed ? 'passing' : 'failing',
+        last_validated: report.timestamp || new Date().toISOString(),
+        violations: report.violations || 0,
+        gates: report.gates || {}
+      };
+    } catch (error) {
+      // Fall through to default
+    }
+  }
+
+  return {
+    status: 'not_validated',
+    last_validated: null,
+    violations: null
+  };
+}
+
 /**
  * Provenance command handler
  * @param {string} subcommand - The subcommand to execute
@@ -87,12 +118,7 @@ async function updateProvenance(options) {
       mode: spec.mode,
       waiver_ids: spec.waiver_ids || [],
     },
-    quality_gates: {
-      // This would be populated by recent validation results
-      // For now, we'll mark as unknown
-      status: 'unknown',
-      last_validated: new Date().toISOString(),
-    },
+    quality_gates: getQualityGatesStatus(),
     agent: {
       type: detectAgentType(),
       confidence_level: null, // Would be populated by agent actions
@@ -407,6 +433,67 @@ function analyzeQualityMetrics(aiEntries) {
 /**
  * Analyze checkpoint usage patterns
  */
+/**
+ * Calculate actual revert rate from git history
+ * Analyzes commits for revert patterns and calculates the percentage
+ * @param {number} maxCommits - Maximum number of commits to analyze
+ * @returns {number} Revert rate as a decimal (0.0 - 1.0)
+ */
+function calculateRevertRate(maxCommits = 500) {
+  try {
+    // Get total commit count (limited)
+    const logOutput = execSync(`git log --oneline -n ${maxCommits} 2>/dev/null`, {
+      encoding: 'utf8',
+      cwd: process.cwd(),
+    }).trim();
+
+    if (!logOutput) {
+      return 0;
+    }
+
+    const totalCommits = logOutput.split('\n').filter(Boolean).length;
+
+    // Count revert commits (commits with "revert" in the message)
+    const revertOutput = execSync(
+      `git log --oneline -n ${maxCommits} --grep="[Rr]evert" 2>/dev/null || true`,
+      {
+        encoding: 'utf8',
+        cwd: process.cwd(),
+      }
+    ).trim();
+
+    const revertCommits = revertOutput ? revertOutput.split('\n').filter(Boolean).length : 0;
+
+    // Also check for reset/force-push patterns in reflog if available
+    let additionalReverts = 0;
+    try {
+      const reflogOutput = execSync(`git reflog --oneline -n ${maxCommits} 2>/dev/null || true`, {
+        encoding: 'utf8',
+        cwd: process.cwd(),
+      }).trim();
+
+      if (reflogOutput) {
+        const reflogLines = reflogOutput.split('\n').filter(Boolean);
+        additionalReverts = reflogLines.filter(
+          (line) => line.includes('reset:') || line.includes('checkout:')
+        ).length;
+        // Weight reflog reverts less since they may not be actual code reverts
+        additionalReverts = Math.floor(additionalReverts * 0.1);
+      }
+    } catch {
+      // Reflog not available or failed
+    }
+
+    const totalReverts = revertCommits + additionalReverts;
+    const revertRate = totalCommits > 0 ? totalReverts / totalCommits : 0;
+
+    return Math.min(1.0, revertRate); // Cap at 100%
+  } catch {
+    // Git not available or not a repo
+    return 0;
+  }
+}
+
 function analyzeCheckpointUsage(aiEntries) {
   const entriesWithCheckpoints = aiEntries.filter(
     (entry) => entry.checkpoints?.available && entry.checkpoints.checkpoints?.length > 0
@@ -416,8 +503,8 @@ function analyzeCheckpointUsage(aiEntries) {
     .filter((entry) => entry.checkpoints?.available)
     .reduce((sum, entry) => sum + (entry.checkpoints.checkpoints?.length || 0), 0);
 
-  // Mock revert rate - in real implementation, this would track actual reverts
-  const revertRate = 0.15; // 15% estimated revert rate
+  // Calculate actual revert rate from git history
+  const revertRate = calculateRevertRate();
 
   return {
     entriesWithCheckpoints,
@@ -753,57 +840,63 @@ function provideAIInsights(contributionPatterns, qualityMetrics, checkpointAnaly
 
 /**
  * Get Cursor AI code tracking data for a commit
+ * Uses Cursor's AI Code Tracking API (Enterprise feature)
+ * @see https://cursor.com/docs/account/teams/ai-code-tracking-api
  * @param {string} commitHash - Git commit hash to analyze
  * @returns {Promise<Object>} AI code tracking data
  */
 async function getCursorTrackingData(commitHash) {
+  const apiUrl = process.env.CURSOR_TRACKING_API;
+  const apiKey = process.env.CURSOR_API_KEY;
+
+  if (!apiUrl || !apiKey) {
+    return {
+      available: false,
+      reason: 'Cursor API not configured. Set CURSOR_TRACKING_API and CURSOR_API_KEY environment variables.',
+      documentation: 'https://cursor.com/docs/account/teams/ai-code-tracking-api'
+    };
+  }
+
   try {
-    // Check if Cursor tracking API is available
-    if (!process.env.CURSOR_TRACKING_API || !process.env.CURSOR_PROJECT_ID) {
-      return { available: false, reason: 'Cursor tracking API not configured' };
+    // Basic auth: base64(apiKey:) - Cursor API uses API key with empty password
+    const auth = Buffer.from(`${apiKey}:`).toString('base64');
+
+    const response = await fetch(`${apiUrl}/analytics/ai-code/commits`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Basic ${auth}`,
+        'Content-Type': 'application/json',
+      }
+    });
+
+    if (!response.ok) {
+      return {
+        available: false,
+        reason: `Cursor API error: ${response.status} ${response.statusText}`
+      };
     }
 
-    // In a real implementation, this would call the Cursor API
-    // For now, we'll return a mock structure showing what data would be available
-    const mockTrackingData = {
+    const data = await response.json();
+
+    // Find commit-specific data if available
+    const commitData = data.commits?.find(c => c.commit_hash === commitHash) || data;
+
+    // Transform API response to our internal format
+    return {
       available: true,
       commit_hash: commitHash,
-      ai_code_breakdown: {
-        tab_completions: {
-          lines_added: 45,
-          percentage: 35,
-          files_affected: ['src/utils.js', 'tests/utils.test.js'],
-        },
-        composer_chat: {
-          lines_added: 78,
-          percentage: 60,
-          files_affected: ['src/new-feature.js', 'src/api.js'],
-          checkpoints_created: 3,
-        },
-        manual_human: {
-          lines_added: 5,
-          percentage: 5,
-          files_affected: ['README.md'],
-        },
+      ai_code_breakdown: commitData.ai_code_breakdown || {
+        tab_completions: { lines_added: 0, percentage: 0, files_affected: [] },
+        composer_chat: { lines_added: 0, percentage: 0, files_affected: [], checkpoints_created: 0 },
+        manual_human: { lines_added: 0, percentage: 0, files_affected: [] },
       },
-      change_groups: [
-        {
-          change_id: 'cg_12345',
-          type: 'composer_session',
-          lines_ai_generated: 42,
-          lines_human_edited: 8,
-          confidence_score: 0.85,
-          timestamp: new Date().toISOString(),
-        },
-      ],
-      quality_metrics: {
-        ai_code_quality_score: 0.78,
-        human_override_rate: 0.12,
-        acceptance_rate: 0.94,
+      change_groups: commitData.change_groups || [],
+      quality_metrics: commitData.quality_metrics || {
+        ai_code_quality_score: 0,
+        human_override_rate: 0,
+        acceptance_rate: 0,
       },
     };
-
-    return mockTrackingData;
   } catch (error) {
     return {
       available: false,
@@ -888,62 +981,92 @@ async function initProvenance(options) {
 
 /**
  * Get Cursor Composer/Chat checkpoint data
- * @returns {Promise<Array>} Array of checkpoint data
+ * Reads from local .cursor/ directory since checkpoints are stored locally by Cursor Agent
+ * @returns {Promise<Object>} Checkpoint data
  */
 async function getCursorCheckpoints() {
+  const cursorDir = path.join(process.cwd(), '.cursor');
+
+  if (!fs.existsSync(cursorDir)) {
+    return {
+      available: false,
+      reason: 'No .cursor directory found. Checkpoints are only available when using Cursor IDE.'
+    };
+  }
+
   try {
-    // Check if Cursor checkpoint API is available
-    if (!process.env.CURSOR_CHECKPOINT_API) {
-      return { available: false, reason: 'Cursor checkpoint API not configured' };
+    // Look for checkpoint metadata in .cursor directory
+    // Cursor stores checkpoints locally during Composer/Agent sessions
+    const checkpointPatterns = [
+      '.cursor/**/checkpoint*.json',
+      '.cursor/**/checkpoints.json',
+      '.cursor/composer/checkpoints/*.json',
+      '.cursor/agent/checkpoints/*.json',
+    ];
+
+    let checkpointFiles = [];
+    for (const pattern of checkpointPatterns) {
+      const glob = require('glob');
+      const matches = glob.sync(pattern, { cwd: process.cwd(), absolute: true });
+      checkpointFiles = checkpointFiles.concat(matches);
     }
 
-    // In a real implementation, this would call the Cursor checkpoint API
-    // For now, we'll return a mock structure
-    const mockCheckpoints = [
-      {
-        id: 'cp_001',
-        timestamp: new Date(Date.now() - 3600000).toISOString(), // 1 hour ago
-        description: 'Initial AI-generated function structure',
-        changes_summary: {
-          lines_added: 25,
-          lines_modified: 0,
-          files_affected: ['src/new-feature.js'],
-        },
-        ai_confidence: 0.82,
-        can_revert: true,
-      },
-      {
-        id: 'cp_002',
-        timestamp: new Date(Date.now() - 1800000).toISOString(), // 30 min ago
-        description: 'Added error handling and validation',
-        changes_summary: {
-          lines_added: 15,
-          lines_modified: 8,
-          files_affected: ['src/new-feature.js', 'tests/new-feature.test.js'],
-        },
-        ai_confidence: 0.91,
-        can_revert: true,
-      },
-      {
-        id: 'cp_003',
-        timestamp: new Date().toISOString(), // Current
-        description: 'Final implementation with documentation',
-        changes_summary: {
-          lines_added: 12,
-          lines_modified: 5,
-          files_affected: ['src/new-feature.js', 'README.md'],
-        },
-        ai_confidence: 0.88,
-        can_revert: false, // Latest checkpoint
-      },
-    ];
+    // Remove duplicates
+    checkpointFiles = [...new Set(checkpointFiles)];
+
+    if (checkpointFiles.length === 0) {
+      return {
+        available: false,
+        reason: 'No checkpoints found in current session. Checkpoints are created during Cursor Composer/Agent sessions.'
+      };
+    }
+
+    // Parse checkpoint files and aggregate data
+    const checkpoints = [];
+    for (const file of checkpointFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const data = JSON.parse(content);
+
+        // Handle both single checkpoint and array of checkpoints
+        if (Array.isArray(data)) {
+          checkpoints.push(...data);
+        } else if (data.checkpoints) {
+          checkpoints.push(...data.checkpoints);
+        } else if (data.id || data.timestamp) {
+          checkpoints.push(data);
+        }
+      } catch (parseError) {
+        // Skip invalid checkpoint files
+        continue;
+      }
+    }
+
+    if (checkpoints.length === 0) {
+      return {
+        available: false,
+        reason: 'No valid checkpoints found in checkpoint files.'
+      };
+    }
+
+    // Sort by timestamp (newest first)
+    checkpoints.sort((a, b) => {
+      const timeA = new Date(a.timestamp || 0).getTime();
+      const timeB = new Date(b.timestamp || 0).getTime();
+      return timeB - timeA;
+    });
+
+    // Mark latest checkpoint as non-revertible
+    if (checkpoints.length > 0) {
+      checkpoints[0].can_revert = false;
+    }
 
-    return { available: true, checkpoints: mockCheckpoints };
+    return { available: true, checkpoints };
   } catch (error) {
     return {
       available: false,
       error: error.message,
-      reason: 'Failed to retrieve Cursor checkpoint data',
+      reason: 'Failed to read Cursor checkpoint data',
     };
   }
 }

package/dist/commands/quality-gates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quality-gates.d.ts","sourceRoot":"","sources":["../../src/commands/quality-gates.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,iEA4ZC"}
+{"version":3,"file":"quality-gates.d.ts","sourceRoot":"","sources":["../../src/commands/quality-gates.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,iEA8ZC"}

package/dist/commands/quality-gates.js

@@ -339,9 +339,11 @@ async function qualityGatesCommand(options = {}) {
       Output.info(`Command: ${args.join(' ')}`);
 
       // Execute the quality gates runner with timeout
+      // CRITICAL: Must run from projectRoot (user's current directory) so that
+      // git commands resolve correctly to the user's repository, not the CLI installation
       const child = spawn(args[0], args.slice(1), {
         stdio: 'inherit',
-        cwd: packagesDir,
+        cwd: projectRoot,
         env: env,
       });
 

package/dist/commands/specs.js

@@ -164,9 +164,9 @@ async function createSpec(id, options = {}) {
         console.log(chalk.blue(`📝 Creating spec with new name: ${newId}`));
         return await createSpec(newId, { ...options, interactive: false });
       } else if (answer === 'merge') {
-        console.log(chalk.yellow('🔄 Merge functionality not yet implemented.'));
-        console.log(chalk.blue('💡 For now, consider creating with a different name.'));
-        return null;
+        // Merge new spec data with existing spec
+        console.log(chalk.blue('🔄 Merging with existing spec...'));
+        return await mergeSpec(id, options);
       } else if (answer === 'override') {
         console.log(chalk.yellow('⚠️  Overriding existing spec...'));
       }
@@ -385,6 +385,133 @@ async function updateSpec(id, updates = {}) {
   return true;
 }
 
+/**
+ * Merge new spec data with an existing spec
+ * Combines acceptance criteria, updates metadata, preserves history
+ * @param {string} id - Spec identifier
+ * @param {Object} options - Options including new spec data to merge
+ * @returns {Promise<Object>} Merged spec
+ */
+async function mergeSpec(id, options = {}) {
+  const existingSpec = await loadSpec(id);
+  if (!existingSpec) {
+    throw new Error(`Spec '${id}' not found`);
+  }
+
+  console.log(chalk.blue(`\n📋 Merging into existing spec: ${id}`));
+  console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  // Show existing spec summary
+  console.log(chalk.gray(`Existing spec:`));
+  console.log(chalk.gray(`   Title: ${existingSpec.title}`));
+  console.log(chalk.gray(`   Status: ${existingSpec.status}`));
+  console.log(
+    chalk.gray(`   Acceptance Criteria: ${existingSpec.acceptance_criteria?.length || 0}`)
+  );
+  console.log('');
+
+  // Prepare merge data from options
+  const {
+    title: newTitle,
+    description: newDescription,
+    acceptance_criteria: newCriteria,
+    mode: newMode,
+    risk_tier: newRiskTier,
+  } = options;
+
+  const mergedSpec = { ...existingSpec };
+
+  // Track what was merged
+  const mergeLog = [];
+
+  // Merge title (prefer new if provided)
+  if (newTitle && newTitle !== existingSpec.title) {
+    mergedSpec.title = newTitle;
+    mergeLog.push(`Title updated: "${existingSpec.title}" → "${newTitle}"`);
+  }
+
+  // Merge description
+  if (newDescription) {
+    if (existingSpec.description) {
+      mergedSpec.description = `${existingSpec.description}\n\n---\n\n${newDescription}`;
+      mergeLog.push('Description appended');
+    } else {
+      mergedSpec.description = newDescription;
+      mergeLog.push('Description added');
+    }
+  }
+
+  // Merge acceptance criteria (append new ones, avoid duplicates)
+  if (newCriteria && Array.isArray(newCriteria) && newCriteria.length > 0) {
+    const existingCriteria = existingSpec.acceptance_criteria || [];
+    const existingIds = new Set(existingCriteria.map((c) => c.id));
+
+    const criteriaToAdd = newCriteria.filter((c) => !existingIds.has(c.id));
+    if (criteriaToAdd.length > 0) {
+      mergedSpec.acceptance_criteria = [...existingCriteria, ...criteriaToAdd];
+      mergeLog.push(`Added ${criteriaToAdd.length} new acceptance criteria`);
+    }
+
+    // Also update the 'acceptance' array if it exists
+    if (existingSpec.acceptance) {
+      const existingAcceptIds = new Set(existingSpec.acceptance.map((a) => a.id));
+      const acceptToAdd = newCriteria.filter((c) => !existingAcceptIds.has(c.id));
+      if (acceptToAdd.length > 0) {
+        mergedSpec.acceptance = [...existingSpec.acceptance, ...acceptToAdd];
+      }
+    }
+  }
+
+  // Merge mode (prefer higher tier if both provided)
+  if (newMode && newMode !== existingSpec.mode) {
+    // Mode priority: crisis > standard > minimal
+    const modePriority = { minimal: 1, standard: 2, crisis: 3 };
+    if ((modePriority[newMode] || 0) > (modePriority[existingSpec.mode] || 0)) {
+      mergedSpec.mode = newMode;
+      mergeLog.push(`Mode upgraded: ${existingSpec.mode} → ${newMode}`);
+    }
+  }
+
+  // Merge risk tier (prefer higher risk if both provided)
+  if (newRiskTier && newRiskTier !== existingSpec.risk_tier) {
+    // Risk priority: T1 > T2 > T3
+    const riskPriority = { T3: 1, T2: 2, T1: 3, 3: 1, 2: 2, 1: 3 };
+    if ((riskPriority[newRiskTier] || 0) > (riskPriority[existingSpec.risk_tier] || 0)) {
+      mergedSpec.risk_tier = newRiskTier;
+      mergeLog.push(`Risk tier updated: ${existingSpec.risk_tier} → ${newRiskTier}`);
+    }
+  }
+
+  // Update metadata
+  mergedSpec.updated_at = new Date().toISOString();
+
+  // Add merge history entry
+  if (!mergedSpec.history) {
+    mergedSpec.history = [];
+  }
+  mergedSpec.history.push({
+    action: 'merge',
+    timestamp: new Date().toISOString(),
+    changes: mergeLog,
+  });
+
+  // Save merged spec
+  await updateSpec(id, mergedSpec);
+
+  // Display merge results
+  console.log(chalk.green('✅ Merge completed:'));
+  if (mergeLog.length > 0) {
+    mergeLog.forEach((change) => {
+      console.log(chalk.gray(`   • ${change}`));
+    });
+  } else {
+    console.log(chalk.gray('   • No changes needed (specs were identical)'));
+  }
+  console.log('');
+
+  return mergedSpec;
+}
+
 /**
  * Delete a spec file
  * @param {string} id - Spec identifier
@@ -544,9 +671,12 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   let selectedFeatures = features;
 
   if (options.interactive) {
-    // For now, just use all suggested features
-    // In a full implementation, this would prompt for selection
-    console.log(chalk.blue('\n📋 Using all suggested features for migration'));
+    selectedFeatures = await selectFeaturesInteractively(features);
+    if (selectedFeatures.length === 0) {
+      console.log(chalk.yellow('⚠️  No features selected. Migration cancelled.'));
+      return { migrated: 0, total: features.length, createdSpecs: [], legacySpec: legacySpec.id };
+    }
+    console.log(chalk.blue(`\n📋 Migrating ${selectedFeatures.length} selected features`));
   }
 
   if (options.features && options.features.length > 0) {
@@ -614,6 +744,54 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   };
 }
 
+/**
+ * Interactive feature selection for migration
+ * @param {Array} features - Array of suggested features
+ * @returns {Promise<Array>} Selected features
+ */
+async function selectFeaturesInteractively(features) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(chalk.cyan('\n📋 Select features to migrate:\n'));
+  features.forEach((f, i) => {
+    const scope = f.scope?.in?.join(', ') || 'N/A';
+    console.log(`  ${chalk.yellow(i + 1)}. ${chalk.bold(f.id || f.name)} - ${f.title || f.description}`);
+    console.log(chalk.gray(`     Scope: ${scope}`));
+  });
+  console.log(chalk.cyan(`\nEnter numbers separated by commas, or 'all' for all features:`));
+  console.log(chalk.gray(`Example: 1,3,5 or all`));
+
+  try {
+    const answer = await question(rl, '> ');
+    const trimmed = answer.trim().toLowerCase();
+
+    if (trimmed === 'all' || trimmed === '*') {
+      return features;
+    }
+
+    if (trimmed === '' || trimmed === 'none' || trimmed === 'q' || trimmed === 'quit') {
+      return [];
+    }
+
+    // Parse comma-separated numbers
+    const indices = trimmed
+      .split(',')
+      .map(n => parseInt(n.trim(), 10) - 1)
+      .filter(i => !isNaN(i) && i >= 0 && i < features.length);
+
+    // Remove duplicates and sort
+    const uniqueIndices = [...new Set(indices)].sort((a, b) => a - b);
+
+    return features.filter((_, i) => uniqueIndices.includes(i));
+  } finally {
+    await closeReadline(rl);
+  }
+}
+
 /**
  * Ask user how to resolve spec creation conflicts
  * @returns {Promise<string>} User's choice: 'cancel', 'rename', 'merge', 'override'

package/dist/commands/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.js"],"names":[],"mappings":"AA8uBA;;;GAGG;AACH,2DA+IC;AAp3BD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAahC;AAgBD;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAgC3B;AAED;;;GAGG;AACH,uCAFa,OAAO,KAAQ,CA+B3B;AAED;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA0D3B;AAED;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAS3B;AAwBD;;;GAGG;AACH,+CAgGC;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,EAAE,CAoCpB"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.js"],"names":[],"mappings":"AA02BA;;;GAGG;AACH,2DA+IC;AA/+BD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAahC;AAgBD;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAgC3B;AAED;;;GAGG;AACH,uCAFa,OAAO,KAAQ,CA+B3B;AAED;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA0D3B;AAED;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAO3B;AA8HD;;;GAGG;AACH,+CAgGC;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,EAAE,CAoCpB"}