@paths.design/caws-cli 4.0.0 → 4.1.0

package/dist/commands/mode.js

@@ -0,0 +1,259 @@
+/**
+ * @fileoverview CAWS Mode Command
+ * Manage CAWS complexity tiers and switch between modes
+ * @author @darianrosebrook
+ */
+
+const chalk = require('chalk');
+const { safeAsync, outputResult } = require('../error-handler');
+
+const {
+  getTier,
+  getAvailableTiers,
+  getCurrentMode,
+  setCurrentMode,
+  displayTierComparison,
+  getTierRecommendation,
+} = require('../config/modes');
+
+/**
+ * Display current mode status
+ */
+function displayCurrentMode() {
+  console.log(chalk.bold.cyan('\n🔧 CAWS Current Mode'));
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  // This will be implemented when we load the current mode
+  console.log(chalk.yellow('Mode display will be implemented...'));
+  console.log('');
+}
+
+/**
+ * Display mode details
+ * @param {string} mode - Mode to display
+ */
+function displayModeDetails(mode) {
+  const tier = getTier(mode);
+  const tierColor = tier.color;
+  const icon = tier.icon;
+
+  console.log(chalk.bold.cyan(`\n📋 ${icon} ${tierColor(tier.name)} Mode Details`));
+  console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  console.log(`${tierColor(tier.name)} - ${tier.description}\n`);
+
+  // Quality Requirements
+  console.log(chalk.bold('Quality Requirements:'));
+  console.log(chalk.gray(`   Test Coverage: ${tier.qualityRequirements.testCoverage}%`));
+  console.log(chalk.gray(`   Mutation Score: ${tier.qualityRequirements.mutationScore}%`));
+  console.log(chalk.gray(`   Contracts: ${tier.qualityRequirements.contracts}\n`));
+
+  // Supported Risk Tiers
+  console.log(chalk.bold('Supported Risk Tiers:'));
+  tier.riskTiers.forEach((riskTier) => {
+    const riskColor =
+      riskTier === 'T1' ? chalk.red : riskTier === 'T2' ? chalk.yellow : chalk.green;
+    console.log(chalk.gray(`   ${riskColor(riskTier)}`));
+  });
+  console.log('');
+
+  // Available Commands
+  console.log(chalk.bold('Available Commands:'));
+  Object.entries(tier.commands)
+    .filter(([, available]) => available)
+    .forEach(([command]) => {
+      console.log(chalk.gray(`   ✅ caws ${command}`));
+    });
+
+  const disabledCommands = Object.entries(tier.commands)
+    .filter(([, available]) => !available)
+    .map(([command]) => command);
+
+  if (disabledCommands.length > 0) {
+    console.log(chalk.bold('\nDisabled Commands:'));
+    disabledCommands.forEach((command) => {
+      console.log(chalk.gray(`   ❌ caws ${command}`));
+    });
+  }
+
+  console.log('');
+}
+
+/**
+ * Interactive mode selection
+ * @returns {Promise<string>} Selected mode
+ */
+async function interactiveModeSelection() {
+  const readline = require('readline');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    console.log(chalk.bold.cyan('\n🔧 Select CAWS Complexity Tier'));
+    console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+    const tiers = getAvailableTiers();
+    tiers.forEach((tier, index) => {
+      const tierConfig = getTier(tier);
+      const tierColor = tierConfig.color;
+      const icon = tierConfig.icon;
+      console.log(`${index + 1}. ${icon} ${tierColor(tier)} - ${tierConfig.description}`);
+    });
+
+    console.log('\nEnter your choice (1-3): ');
+
+    rl.on('line', (input) => {
+      const choice = parseInt(input.trim());
+      if (choice >= 1 && choice <= tiers.length) {
+        rl.close();
+        resolve(tiers[choice - 1]);
+      } else {
+        console.log(chalk.red('Invalid choice. Please enter 1-3:'));
+      }
+    });
+  });
+}
+
+/**
+ * Mode command handler
+ * @param {string} action - Action to perform (current, set, compare, recommend)
+ * @param {Object} options - Command options
+ */
+async function modeCommand(action, options = {}) {
+  return safeAsync(
+    async () => {
+      switch (action) {
+        case 'current': {
+          const currentMode = await getCurrentMode();
+          displayCurrentMode();
+
+          const tier = getTier(currentMode);
+          console.log(chalk.bold(`Current Mode: ${tier.icon} ${tier.color(currentMode)}`));
+          console.log(chalk.gray(`Description: ${tier.description}`));
+          console.log(
+            chalk.gray(
+              `Quality: ${tier.qualityRequirements.testCoverage}% coverage, ${tier.qualityRequirements.mutationScore}% mutation`
+            )
+          );
+
+          return outputResult({
+            command: 'mode current',
+            mode: currentMode,
+            tier: tier,
+          });
+        }
+
+        case 'set': {
+          let targetMode;
+
+          if (options.mode) {
+            targetMode = options.mode;
+          } else if (options.interactive) {
+            targetMode = await interactiveModeSelection();
+          } else {
+            throw new Error('Mode not specified. Use --mode <mode> or --interactive');
+          }
+
+          if (!getAvailableTiers().includes(targetMode)) {
+            throw new Error(
+              `Invalid mode: ${targetMode}. Available: ${getAvailableTiers().join(', ')}`
+            );
+          }
+
+          const success = await setCurrentMode(targetMode);
+          if (!success) {
+            throw new Error(`Failed to set mode to ${targetMode}`);
+          }
+
+          console.log(
+            chalk.green(
+              `✅ Successfully switched to ${getTier(targetMode).icon} ${getTier(targetMode).color(targetMode)} mode`
+            )
+          );
+
+          return outputResult({
+            command: 'mode set',
+            mode: targetMode,
+          });
+        }
+
+        case 'compare': {
+          displayTierComparison();
+
+          return outputResult({
+            command: 'mode compare',
+            tiers: getAvailableTiers(),
+          });
+        }
+
+        case 'recommend': {
+          const projectInfo = {};
+
+          if (options.size) projectInfo.size = options.size;
+          if (options.teamSize) projectInfo.teamSize = parseInt(options.teamSize);
+          if (options.compliance) projectInfo.compliance = options.compliance === 'true';
+          if (options.audit) projectInfo.auditRequired = options.audit === 'true';
+
+          const recommendation = getTierRecommendation(projectInfo);
+          const recommendedTier = getTier(recommendation);
+
+          console.log(chalk.bold.cyan('\n🎯 Recommended CAWS Tier'));
+          console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+          console.log(
+            `${recommendedTier.icon} ${recommendedTier.color(recommendedTier.name)} - ${recommendedTier.description}`
+          );
+          console.log(
+            chalk.gray(
+              `Quality: ${recommendedTier.qualityRequirements.testCoverage}% coverage, ${recommendedTier.qualityRequirements.mutationScore}% mutation`
+            )
+          );
+
+          if (options.details) {
+            console.log('');
+            displayModeDetails(recommendation);
+          }
+
+          return outputResult({
+            command: 'mode recommend',
+            recommendation,
+            tier: recommendedTier,
+            projectInfo,
+          });
+        }
+
+        case 'details': {
+          if (!options.mode) {
+            throw new Error('Mode not specified. Use --mode <mode>');
+          }
+
+          displayModeDetails(options.mode);
+
+          return outputResult({
+            command: 'mode details',
+            mode: options.mode,
+          });
+        }
+
+        default:
+          throw new Error(
+            `Unknown mode action: ${action}. Use: current, set, compare, recommend, details`
+          );
+      }
+    },
+    `mode ${action}`,
+    true
+  );
+}
+
+module.exports = {
+  modeCommand,
+  getCurrentMode,
+  setCurrentMode,
+  displayCurrentMode,
+  displayModeDetails,
+  interactiveModeSelection,
+};

package/dist/commands/plan.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Plan command handler
+ * @param {string} action - Action to perform (generate)
+ * @param {Object} options - Command options
+ */
+export function planCommand(action: string, options?: any): Promise<any>;
+/**
+ * Generate implementation plan from spec
+ * @param {Object} spec - Spec data
+ * @returns {Object} Generated plan
+ */
+export function generateImplementationPlan(spec: any): any;
+/**
+ * Write plan to file
+ * @param {Object} plan - Plan data
+ * @param {string} outputPath - Output file path
+ * @returns {Promise<void>}
+ */
+export function writePlanToFile(plan: any, outputPath: string): Promise<void>;
+/**
+ * Generate markdown content from plan
+ * @param {Object} plan - Plan data
+ * @returns {string} Markdown content
+ */
+export function generatePlanMarkdown(plan: any): string;
+/**
+ * Display generated plan
+ * @param {Object} plan - Plan data
+ */
+export function displayGeneratedPlan(plan: any): void;
+export namespace PLAN_TEMPLATES {
+    namespace feature {
+        let sections: string[];
+        let defaultTasks: string[];
+    }
+    namespace fix {
+        let sections_1: string[];
+        export { sections_1 as sections };
+        let defaultTasks_1: string[];
+        export { defaultTasks_1 as defaultTasks };
+    }
+    namespace refactor {
+        let sections_2: string[];
+        export { sections_2 as sections };
+        let defaultTasks_2: string[];
+        export { defaultTasks_2 as defaultTasks };
+    }
+}
+//# sourceMappingURL=plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/commands/plan.js"],"names":[],"mappings":"AA6XA;;;;GAIG;AACH,oCAHW,MAAM,+BAuDhB;AA1OD;;;;GAIG;AACH,2DA8CC;AAED;;;;;GAKG;AACH,uDAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAQzB;AAED;;;;GAIG;AACH,iDAFa,MAAM,CAiElB;AAED;;;GAGG;AACH,sDAkCC"}