claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/init/validation/mode-validator.js

@@ -1,387 +1,336 @@
-import { promises as fs } from 'fs';
+import { promises as fs } from "fs";
 // mode-validator.js - SPARC mode functionality testing
-
 export class ModeValidator {
-  constructor(workingDir) {
-    this.workingDir = workingDir;
-  }
-
-  /**
+    /**
    * Test all SPARC modes for basic functionality
-   */
-  async testAllModes() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      modes: {},
-    };
-
-    try {
-      // First, check if SPARC is initialized
-      const sparcInitialized = await this.checkSparcInitialization();
-      if (!sparcInitialized.initialized) {
-        result.warnings.push('SPARC not initialized - mode testing skipped');
-        return result;
-      }
-
-      // Get available modes
-      const availableModes = await this.getAvailableModes();
-      if (availableModes.length === 0) {
-        result.warnings.push('No SPARC modes found for testing');
-        return result;
-      }
-
-      // Test each mode
-      for (const mode of availableModes) {
-        const modeTest = await this.testMode(mode);
-        result.modes[mode] = modeTest;
-
-        if (!modeTest.success) {
-          result.success = false;
-          result.errors.push(`Mode ${mode} failed testing: ${modeTest.error}`);
+   */ async testAllModes() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            modes: {}
+        };
+        try {
+            // First, check if SPARC is initialized
+            const sparcInitialized = await this.checkSparcInitialization();
+            if (!sparcInitialized.initialized) {
+                result.warnings.push('SPARC not initialized - mode testing skipped');
+                return result;
+            }
+            // Get available modes
+            const availableModes = await this.getAvailableModes();
+            if (availableModes.length === 0) {
+                result.warnings.push('No SPARC modes found for testing');
+                return result;
+            }
+            // Test each mode
+            for (const mode of availableModes){
+                const modeTest = await this.testMode(mode);
+                result.modes[mode] = modeTest;
+                if (!modeTest.success) {
+                    result.success = false;
+                    result.errors.push(`Mode ${mode} failed testing: ${modeTest.error}`);
+                }
+            }
+        } catch (error) {
+            result.success = false;
+            result.errors.push(`Mode testing failed: ${error.message}`);
         }
-      }
-    } catch (error) {
-      result.success = false;
-      result.errors.push(`Mode testing failed: ${error.message}`);
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Test a specific SPARC mode
-   */
-  async testMode(modeName) {
-    const result = {
-      success: true,
-      error: null,
-      checks: {
-        accessible: false,
-        configValid: false,
-        executable: false,
-      },
-    };
-
-    try {
-      // Test 1: Check if mode is accessible via CLI
-      const accessTest = await this.testModeAccess(modeName);
-      result.checks.accessible = accessTest.success;
-      if (!accessTest.success) {
-        result.success = false;
-        result.error = accessTest.error;
-        return result;
-      }
-
-      // Test 2: Validate mode configuration
-      const configTest = await this.testModeConfig(modeName);
-      result.checks.configValid = configTest.success;
-      if (!configTest.success) {
-        result.success = false;
-        result.error = configTest.error;
-        return result;
-      }
-
-      // Test 3: Test mode execution (dry run)
-      const execTest = await this.testModeExecution(modeName);
-      result.checks.executable = execTest.success;
-      if (!execTest.success) {
-        result.success = false;
-        result.error = execTest.error;
+   */ async testMode(modeName) {
+        const result = {
+            success: true,
+            error: null,
+            checks: {
+                accessible: false,
+                configValid: false,
+                executable: false
+            }
+        };
+        try {
+            // Test 1: Check if mode is accessible via CLI
+            const accessTest = await this.testModeAccess(modeName);
+            result.checks.accessible = accessTest.success;
+            if (!accessTest.success) {
+                result.success = false;
+                result.error = accessTest.error;
+                return result;
+            }
+            // Test 2: Validate mode configuration
+            const configTest = await this.testModeConfig(modeName);
+            result.checks.configValid = configTest.success;
+            if (!configTest.success) {
+                result.success = false;
+                result.error = configTest.error;
+                return result;
+            }
+            // Test 3: Test mode execution (dry run)
+            const execTest = await this.testModeExecution(modeName);
+            result.checks.executable = execTest.success;
+            if (!execTest.success) {
+                result.success = false;
+                result.error = execTest.error;
+                return result;
+            }
+        } catch (error) {
+            result.success = false;
+            result.error = error.message;
+        }
         return result;
-      }
-    } catch (error) {
-      result.success = false;
-      result.error = error.message;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Check if SPARC is properly initialized
-   */
-  async checkSparcInitialization() {
-    const result = {
-      initialized: false,
-      hasRoomodes: false,
-      hasExecutable: false,
-      error: null,
-    };
-
-    try {
-      // Check for .roomodes file
-      try {
-        const stat = await Deno.stat(`${this.workingDir}/.roomodes`);
-        result.hasRoomodes = stat.isFile;
-      } catch {
-        result.error = '.roomodes file not found';
-      }
-
-      // Check for claude-flow-novice executable
-      try {
-        const stat = await Deno.stat(`${this.workingDir}/claude-flow`);
-        result.hasExecutable = stat.isFile;
-      } catch {
-        result.error = 'claude-flow-novice executable not found';
-      }
-
-      result.initialized = result.hasRoomodes && result.hasExecutable;
-    } catch (error) {
-      result.error = error.message;
+   */ async checkSparcInitialization() {
+        const result = {
+            initialized: false,
+            hasRoomodes: false,
+            hasExecutable: false,
+            error: null
+        };
+        try {
+            // Check for .roomodes file
+            try {
+                const stat = await Deno.stat(`${this.workingDir}/.roomodes`);
+                result.hasRoomodes = stat.isFile;
+            } catch  {
+                result.error = '.roomodes file not found';
+            }
+            // Check for claude-flow-novice executable
+            try {
+                const stat = await Deno.stat(`${this.workingDir}/claude-flow`);
+                result.hasExecutable = stat.isFile;
+            } catch  {
+                result.error = 'claude-flow-novice executable not found';
+            }
+            result.initialized = result.hasRoomodes && result.hasExecutable;
+        } catch (error) {
+            result.error = error.message;
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Get list of available SPARC modes
-   */
-  async getAvailableModes() {
-    const modes = [];
-
-    try {
-      // Try to get modes from .roomodes
-      const roomodesPath = `${this.workingDir}/.roomodes`;
-      const content = await fs.readFile(roomodesPath, 'utf8');
-      const config = JSON.parse(content);
-
-      if (config.modes && typeof config.modes === 'object') {
-        modes.push(...Object.keys(config.modes));
-      }
-    } catch (error) {
-      // Fallback to common modes
-      modes.push(
-        'architect',
-        'code',
-        'tdd',
-        'spec-pseudocode',
-        'integration',
-        'debug',
-        'docs-writer',
-      );
+   */ async getAvailableModes() {
+        const modes = [];
+        try {
+            // Try to get modes from .roomodes
+            const roomodesPath = `${this.workingDir}/.roomodes`;
+            const content = await fs.readFile(roomodesPath, 'utf8');
+            const config = JSON.parse(content);
+            if (config.modes && typeof config.modes === 'object') {
+                modes.push(...Object.keys(config.modes));
+            }
+        } catch (error) {
+            // Fallback to common modes
+            modes.push('architect', 'code', 'tdd', 'spec-pseudocode', 'integration', 'debug', 'docs-writer');
+        }
+        return modes;
     }
-
-    return modes;
-  }
-
-  /**
+    /**
    * Test if a mode is accessible via CLI
-   */
-  async testModeAccess(modeName) {
-    const result = {
-      success: false,
-      error: null,
-    };
-
-    try {
-      // Test with sparc info command
-      const command = new Deno.Command('./claude-flow', {
-        args: ['sparc', 'info', modeName],
-        cwd: this.workingDir,
-        stdout: 'piped',
-        stderr: 'piped',
-      });
-
-      const { success, stdout, stderr } = await command.output();
-
-      if (success) {
-        result.success = true;
-      } else {
-        const errorOutput = new TextDecoder().decode(stderr);
-        result.error = `Mode not accessible: ${errorOutput}`;
-      }
-    } catch (error) {
-      result.error = `Failed to test mode access: ${error.message}`;
+   */ async testModeAccess(modeName) {
+        const result = {
+            success: false,
+            error: null
+        };
+        try {
+            // Test with sparc info command
+            const command = new Deno.Command('./claude-flow', {
+                args: [
+                    'sparc',
+                    'info',
+                    modeName
+                ],
+                cwd: this.workingDir,
+                stdout: 'piped',
+                stderr: 'piped'
+            });
+            const { success, stdout, stderr } = await command.output();
+            if (success) {
+                result.success = true;
+            } else {
+                const errorOutput = new TextDecoder().decode(stderr);
+                result.error = `Mode not accessible: ${errorOutput}`;
+            }
+        } catch (error) {
+            result.error = `Failed to test mode access: ${error.message}`;
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Test mode configuration validity
-   */
-  async testModeConfig(modeName) {
-    const result = {
-      success: false,
-      error: null,
-    };
-
-    try {
-      // Read .roomodes and validate mode config
-      const roomodesPath = `${this.workingDir}/.roomodes`;
-      const content = await fs.readFile(roomodesPath, 'utf8');
-      const config = JSON.parse(content);
-
-      if (!config.modes || !config.modes[modeName]) {
-        result.error = `Mode ${modeName} not found in configuration`;
-        return result;
-      }
-
-      const modeConfig = config.modes[modeName];
-
-      // Basic validation
-      if (typeof modeConfig !== 'object') {
-        result.error = `Invalid configuration for mode ${modeName}`;
-        return result;
-      }
-
-      // Check for required fields
-      const requiredFields = ['description'];
-      for (const field of requiredFields) {
-        if (!modeConfig[field]) {
-          result.error = `Mode ${modeName} missing required field: ${field}`;
-          return result;
+   */ async testModeConfig(modeName) {
+        const result = {
+            success: false,
+            error: null
+        };
+        try {
+            // Read .roomodes and validate mode config
+            const roomodesPath = `${this.workingDir}/.roomodes`;
+            const content = await fs.readFile(roomodesPath, 'utf8');
+            const config = JSON.parse(content);
+            if (!config.modes || !config.modes[modeName]) {
+                result.error = `Mode ${modeName} not found in configuration`;
+                return result;
+            }
+            const modeConfig = config.modes[modeName];
+            // Basic validation
+            if (typeof modeConfig !== 'object') {
+                result.error = `Invalid configuration for mode ${modeName}`;
+                return result;
+            }
+            // Check for required fields
+            const requiredFields = [
+                'description'
+            ];
+            for (const field of requiredFields){
+                if (!modeConfig[field]) {
+                    result.error = `Mode ${modeName} missing required field: ${field}`;
+                    return result;
+                }
+            }
+            result.success = true;
+        } catch (error) {
+            result.error = `Configuration validation failed: ${error.message}`;
         }
-      }
-
-      result.success = true;
-    } catch (error) {
-      result.error = `Configuration validation failed: ${error.message}`;
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Test mode execution with a safe dry run
-   */
-  async testModeExecution(modeName) {
-    const result = {
-      success: false,
-      error: null,
-    };
-
-    try {
-      // Test with a safe, non-destructive command
-      const command = new Deno.Command('./claude-flow', {
-        args: ['sparc', 'run', modeName, 'test validation', '--dry-run'],
-        cwd: this.workingDir,
-        stdout: 'piped',
-        stderr: 'piped',
-      });
-
-      const { success, stdout, stderr } = await command.output();
-
-      if (success) {
-        result.success = true;
-      } else {
-        // Check if it's just because --dry-run isn't supported
-        const errorOutput = new TextDecoder().decode(stderr);
-        if (errorOutput.includes('dry-run') || errorOutput.includes('unknown flag')) {
-          // Try without dry-run but with a safe test task
-          const testCommand = new Deno.Command('./claude-flow', {
-            args: ['sparc', 'modes'],
-            cwd: this.workingDir,
-            stdout: 'piped',
-            stderr: 'piped',
-          });
-
-          const testResult = await testCommand.output();
-          if (testResult.success) {
-            const output = new TextDecoder().decode(testResult.stdout);
-            result.success = output.includes(modeName);
-            if (!result.success) {
-              result.error = `Mode ${modeName} not listed in available modes`;
+   */ async testModeExecution(modeName) {
+        const result = {
+            success: false,
+            error: null
+        };
+        try {
+            // Test with a safe, non-destructive command
+            const command = new Deno.Command('./claude-flow', {
+                args: [
+                    'sparc',
+                    'run',
+                    modeName,
+                    'test validation',
+                    '--dry-run'
+                ],
+                cwd: this.workingDir,
+                stdout: 'piped',
+                stderr: 'piped'
+            });
+            const { success, stdout, stderr } = await command.output();
+            if (success) {
+                result.success = true;
+            } else {
+                // Check if it's just because --dry-run isn't supported
+                const errorOutput = new TextDecoder().decode(stderr);
+                if (errorOutput.includes('dry-run') || errorOutput.includes('unknown flag')) {
+                    // Try without dry-run but with a safe test task
+                    const testCommand = new Deno.Command('./claude-flow', {
+                        args: [
+                            'sparc',
+                            'modes'
+                        ],
+                        cwd: this.workingDir,
+                        stdout: 'piped',
+                        stderr: 'piped'
+                    });
+                    const testResult = await testCommand.output();
+                    if (testResult.success) {
+                        const output = new TextDecoder().decode(testResult.stdout);
+                        result.success = output.includes(modeName);
+                        if (!result.success) {
+                            result.error = `Mode ${modeName} not listed in available modes`;
+                        }
+                    } else {
+                        result.error = `Mode execution test failed: ${errorOutput}`;
+                    }
+                } else {
+                    result.error = `Mode execution failed: ${errorOutput}`;
+                }
             }
-          } else {
-            result.error = `Mode execution test failed: ${errorOutput}`;
-          }
-        } else {
-          result.error = `Mode execution failed: ${errorOutput}`;
+        } catch (error) {
+            result.error = `Execution test failed: ${error.message}`;
         }
-      }
-    } catch (error) {
-      result.error = `Execution test failed: ${error.message}`;
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Test SPARC workflow functionality
-   */
-  async testWorkflowFunctionality() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      workflows: {},
-    };
-
-    try {
-      // Check for workflow files
-      const workflowDir = `${this.workingDir}/.roo/workflows`;
-
-      try {
-        const entries = [];
-        for await (const entry of Deno.readDir(workflowDir)) {
-          if (entry.isFile && entry.name.endsWith('.json')) {
-            entries.push(entry.name);
-          }
-        }
-
-        // Test each workflow file
-        for (const workflowFile of entries) {
-          const workflowTest = await this.testWorkflowFile(workflowFile);
-          result.workflows[workflowFile] = workflowTest;
-
-          if (!workflowTest.success) {
-            result.warnings.push(`Workflow ${workflowFile} has issues: ${workflowTest.error}`);
-          }
-        }
-
-        if (entries.length === 0) {
-          result.warnings.push('No workflow files found');
+   */ async testWorkflowFunctionality() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            workflows: {}
+        };
+        try {
+            // Check for workflow files
+            const workflowDir = `${this.workingDir}/.roo/workflows`;
+            try {
+                const entries = [];
+                for await (const entry of Deno.readDir(workflowDir)){
+                    if (entry.isFile && entry.name.endsWith('.json')) {
+                        entries.push(entry.name);
+                    }
+                }
+                // Test each workflow file
+                for (const workflowFile of entries){
+                    const workflowTest = await this.testWorkflowFile(workflowFile);
+                    result.workflows[workflowFile] = workflowTest;
+                    if (!workflowTest.success) {
+                        result.warnings.push(`Workflow ${workflowFile} has issues: ${workflowTest.error}`);
+                    }
+                }
+                if (entries.length === 0) {
+                    result.warnings.push('No workflow files found');
+                }
+            } catch  {
+                result.warnings.push('Workflow directory not accessible');
+            }
+        } catch (error) {
+            result.errors.push(`Workflow testing failed: ${error.message}`);
         }
-      } catch {
-        result.warnings.push('Workflow directory not accessible');
-      }
-    } catch (error) {
-      result.errors.push(`Workflow testing failed: ${error.message}`);
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Test a specific workflow file
-   */
-  async testWorkflowFile(filename) {
-    const result = {
-      success: true,
-      error: null,
-    };
-
-    try {
-      const workflowPath = `${this.workingDir}/.roo/workflows/${filename}`;
-      const content = await fs.readFile(workflowPath, 'utf8');
-
-      // Parse JSON
-      const workflow = JSON.parse(content);
-
-      // Basic validation
-      if (typeof workflow !== 'object' || workflow === null) {
-        result.success = false;
-        result.error = 'Workflow must be a JSON object';
-        return result;
-      }
-
-      // Check for recommended fields
-      const recommendedFields = ['name', 'description', 'steps'];
-      for (const field of recommendedFields) {
-        if (!(field in workflow)) {
-          result.success = false;
-          result.error = `Missing recommended field: ${field}`;
-          return result;
+   */ async testWorkflowFile(filename) {
+        const result = {
+            success: true,
+            error: null
+        };
+        try {
+            const workflowPath = `${this.workingDir}/.roo/workflows/${filename}`;
+            const content = await fs.readFile(workflowPath, 'utf8');
+            // Parse JSON
+            const workflow = JSON.parse(content);
+            // Basic validation
+            if (typeof workflow !== 'object' || workflow === null) {
+                result.success = false;
+                result.error = 'Workflow must be a JSON object';
+                return result;
+            }
+            // Check for recommended fields
+            const recommendedFields = [
+                'name',
+                'description',
+                'steps'
+            ];
+            for (const field of recommendedFields){
+                if (!(field in workflow)) {
+                    result.success = false;
+                    result.error = `Missing recommended field: ${field}`;
+                    return result;
+                }
+            }
+        } catch (error) {
+            result.success = false;
+            result.error = `Workflow validation failed: ${error.message}`;
         }
-      }
-    } catch (error) {
-      result.success = false;
-      result.error = `Workflow validation failed: ${error.message}`;
+        return result;
+    }
+    constructor(workingDir){
+        this.workingDir = workingDir;
     }
-
-    return result;
-  }
 }