claude-flow-novice 1.3.0 → 1.3.2

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

@@ -0,0 +1,390 @@
+import { promises as fs } from 'fs';
+// post-init-validator.js - Post-initialization verification checks
+
+export class PostInitValidator {
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+  }
+
+  /**
+   * Check file integrity (existence, size, readability)
+   */
+  async checkFileIntegrity() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      files: {},
+    };
+
+    const expectedFiles = [
+      { path: 'CLAUDE.md', minSize: 100 },
+      { path: 'memory-bank.md', minSize: 50 },
+      { path: 'coordination.md', minSize: 50 },
+      { path: 'memory/claude-flow-data.json', minSize: 10 },
+      { path: 'memory/agents/README.md', minSize: 10 },
+      { path: 'memory/sessions/README.md', minSize: 10 },
+      { path: 'claude-flow', minSize: 50, executable: true },
+    ];
+
+    for (const file of expectedFiles) {
+      const filePath = `${this.workingDir}/${file.path}`;
+
+      try {
+        const stat = await fs.stat(filePath);
+
+        // Check if it exists and is a file
+        if (!stat.isFile) {
+          result.success = false;
+          result.errors.push(`Expected file but found directory: ${file.path}`);
+          result.files[file.path] = { status: 'not_file' };
+          continue;
+        }
+
+        // Check file size
+        if (stat.size < file.minSize) {
+          result.success = false;
+          result.errors.push(
+            `File too small: ${file.path} (${stat.size} bytes, expected >= ${file.minSize})`,
+          );
+          result.files[file.path] = { status: 'too_small', size: stat.size };
+          continue;
+        }
+
+        // Check if executable (if required)
+        if (file.executable && Deno.build.os !== 'windows') {
+          const isExecutable = (stat.mode & 0o111) !== 0;
+          if (!isExecutable) {
+            result.warnings.push(`File not executable: ${file.path}`);
+            result.files[file.path] = { status: 'not_executable', size: stat.size };
+            continue;
+          }
+        }
+
+        // Try to read the file
+        try {
+          await fs.readFile(filePath, 'utf8');
+          result.files[file.path] = { status: 'ok', size: stat.size };
+        } catch (readError) {
+          result.success = false;
+          result.errors.push(`Cannot read file: ${file.path} - ${readError.message}`);
+          result.files[file.path] = { status: 'unreadable', size: stat.size };
+        }
+      } catch (error) {
+        result.success = false;
+        result.errors.push(`File not found: ${file.path}`);
+        result.files[file.path] = { status: 'missing' };
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check completeness of initialization
+   */
+  async checkCompleteness() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      missing: [],
+    };
+
+    const requiredDirs = [
+      'memory',
+      'memory/agents',
+      'memory/sessions',
+      'coordination',
+      'coordination/memory_bank',
+      'coordination/subtasks',
+      'coordination/orchestration',
+      '.claude',
+      '.claude/commands',
+      '.claude/logs',
+    ];
+
+    const optionalDirs = [
+      '.roo',
+      '.roo/templates',
+      '.roo/workflows',
+      '.roo/modes',
+      '.roo/configs',
+      '.claude/commands/sparc',
+    ];
+
+    // Check required directories
+    for (const dir of requiredDirs) {
+      const dirPath = `${this.workingDir}/${dir}`;
+
+      try {
+        const stat = await fs.stat(dirPath);
+        if (!stat.isDirectory) {
+          result.success = false;
+          result.errors.push(`Expected directory but found file: ${dir}`);
+          result.missing.push(dir);
+        }
+      } catch {
+        result.success = false;
+        result.errors.push(`Required directory missing: ${dir}`);
+        result.missing.push(dir);
+      }
+    }
+
+    // Check optional directories (SPARC-related)
+    for (const dir of optionalDirs) {
+      const dirPath = `${this.workingDir}/${dir}`;
+
+      try {
+        await fs.stat(dirPath);
+      } catch {
+        if (dir.includes('.roo') || dir.includes('sparc')) {
+          result.warnings.push(`Optional SPARC directory missing: ${dir}`);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Validate directory structure and organization
+   */
+  async validateStructure() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      structure: {},
+    };
+
+    try {
+      // Check memory structure
+      const memoryStructure = await this.validateMemoryStructure();
+      result.structure.memory = memoryStructure;
+      if (!memoryStructure.valid) {
+        result.warnings.push('Memory directory structure is incomplete');
+      }
+
+      // Check coordination structure
+      const coordinationStructure = await this.validateCoordinationStructure();
+      result.structure.coordination = coordinationStructure;
+      if (!coordinationStructure.valid) {
+        result.warnings.push('Coordination directory structure is incomplete');
+      }
+
+      // Check Claude integration structure
+      const claudeStructure = await this.validateClaudeStructure();
+      result.structure.claude = claudeStructure;
+      if (!claudeStructure.valid) {
+        result.warnings.push('Claude integration structure is incomplete');
+      }
+
+      // Check SPARC structure (if present)
+      const sparcExists = await this.checkSparcExists();
+      if (sparcExists) {
+        const sparcStructure = await this.validateSparcStructure();
+        result.structure.sparc = sparcStructure;
+        if (!sparcStructure.valid) {
+          result.warnings.push('SPARC structure is incomplete');
+        }
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Structure validation failed: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Check permissions on created files and directories
+   */
+  async checkPermissions() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      permissions: {},
+    };
+
+    const itemsToCheck = [
+      { path: 'CLAUDE.md', type: 'file', requiredMode: 0o644 },
+      { path: 'memory-bank.md', type: 'file', requiredMode: 0o644 },
+      { path: 'coordination.md', type: 'file', requiredMode: 0o644 },
+      { path: 'claude-flow', type: 'file', requiredMode: 0o755 },
+      { path: 'memory', type: 'dir', requiredMode: 0o755 },
+      { path: 'coordination', type: 'dir', requiredMode: 0o755 },
+      { path: '.claude', type: 'dir', requiredMode: 0o755 },
+    ];
+
+    // Skip permission checks on Windows
+    if (Deno.build.os === 'windows') {
+      result.warnings.push('Permission checks skipped on Windows');
+      return result;
+    }
+
+    for (const item of itemsToCheck) {
+      const itemPath = `${this.workingDir}/${item.path}`;
+
+      try {
+        const stat = await fs.stat(itemPath);
+        const actualMode = stat.mode & 0o777;
+        const expectedMode = item.requiredMode;
+
+        result.permissions[item.path] = {
+          actual: actualMode.toString(8),
+          expected: expectedMode.toString(8),
+          correct: actualMode === expectedMode,
+        };
+
+        if (actualMode !== expectedMode) {
+          result.warnings.push(
+            `Incorrect permissions on ${item.path}: ` +
+              `${actualMode.toString(8)} (expected ${expectedMode.toString(8)})`,
+          );
+        }
+      } catch (error) {
+        result.warnings.push(`Could not check permissions for ${item.path}: ${error.message}`);
+      }
+    }
+
+    return result;
+  }
+
+  // Helper methods
+
+  async validateMemoryStructure() {
+    const structure = {
+      valid: true,
+      dirs: [],
+      files: [],
+    };
+
+    const expectedDirs = ['agents', 'sessions'];
+    const expectedFiles = ['claude-flow-data.json', 'agents/README.md', 'sessions/README.md'];
+
+    for (const dir of expectedDirs) {
+      try {
+        await fs.stat(`${this.workingDir}/memory/${dir}`);
+        structure.dirs.push(dir);
+      } catch {
+        structure.valid = false;
+      }
+    }
+
+    for (const file of expectedFiles) {
+      try {
+        await fs.stat(`${this.workingDir}/memory/${file}`);
+        structure.files.push(file);
+      } catch {
+        structure.valid = false;
+      }
+    }
+
+    return structure;
+  }
+
+  async validateCoordinationStructure() {
+    const structure = {
+      valid: true,
+      dirs: [],
+    };
+
+    const expectedDirs = ['memory_bank', 'subtasks', 'orchestration'];
+
+    for (const dir of expectedDirs) {
+      try {
+        await fs.stat(`${this.workingDir}/coordination/${dir}`);
+        structure.dirs.push(dir);
+      } catch {
+        structure.valid = false;
+      }
+    }
+
+    return structure;
+  }
+
+  async validateClaudeStructure() {
+    const structure = {
+      valid: true,
+      dirs: [],
+      hasCommands: false,
+    };
+
+    const expectedDirs = ['commands', 'logs'];
+
+    for (const dir of expectedDirs) {
+      try {
+        await fs.stat(`${this.workingDir}/.claude/${dir}`);
+        structure.dirs.push(dir);
+      } catch {
+        structure.valid = false;
+      }
+    }
+
+    // Check if there are any command files
+    try {
+      const entries = [];
+      for await (const entry of fs.readdir(`${this.workingDir}/.claude/commands`)) {
+        if (entry.isFile && entry.name.endsWith('.js')) {
+          entries.push(entry.name);
+        }
+      }
+      structure.hasCommands = entries.length > 0;
+      structure.commandCount = entries.length;
+    } catch {
+      structure.hasCommands = false;
+    }
+
+    return structure;
+  }
+
+  async checkSparcExists() {
+    try {
+      await fs.stat(`${this.workingDir}/.roomodes`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async validateSparcStructure() {
+    const structure = {
+      valid: true,
+      hasRoomodes: false,
+      hasRooDir: false,
+      dirs: [],
+    };
+
+    // Check .roomodes file
+    try {
+      const stat = await fs.stat(`${this.workingDir}/.roomodes`);
+      structure.hasRoomodes = stat.isFile;
+    } catch {
+      structure.valid = false;
+    }
+
+    // Check .roo directory
+    try {
+      const stat = await fs.stat(`${this.workingDir}/.roo`);
+      structure.hasRooDir = stat.isDirectory;
+
+      if (structure.hasRooDir) {
+        const expectedDirs = ['templates', 'workflows', 'modes', 'configs'];
+        for (const dir of expectedDirs) {
+          try {
+            await fs.stat(`${this.workingDir}/.roo/${dir}`);
+            structure.dirs.push(dir);
+          } catch {
+            // Optional subdirectories
+          }
+        }
+      }
+    } catch {
+      // .roo directory is optional
+    }
+
+    return structure;
+  }
+}

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

@@ -0,0 +1,290 @@
+// pre-init-validator.js - Pre-initialization validation checks
+
+import { printWarning } from '../../../utils.js';
+
+export class PreInitValidator {
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+  }
+
+  /**
+   * Check file system permissions
+   */
+  async checkPermissions() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+    };
+
+    try {
+      // Test write permission in working directory
+      const testFile = `${this.workingDir}/.claude-flow-permission-test`;
+      await Deno.writeTextFile(testFile, 'test');
+      await Deno.remove(testFile);
+
+      // Test directory creation permission
+      const testDir = `${this.workingDir}/.claude-flow-dir-test`;
+      await Deno.mkdir(testDir);
+      await Deno.remove(testDir);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Insufficient permissions in ${this.workingDir}: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Check available disk space
+   */
+  async checkDiskSpace() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+    };
+
+    try {
+      // Get disk usage information
+      const command = new Deno.Command('df', {
+        args: ['-k', this.workingDir],
+        stdout: 'piped',
+        stderr: 'piped',
+      });
+
+      const { stdout, success } = await command.output();
+
+      if (success) {
+        const output = new TextDecoder().decode(stdout);
+        const lines = output.trim().split('\n');
+
+        if (lines.length >= 2) {
+          const dataLine = lines[1];
+          const parts = dataLine.split(/\s+/);
+
+          if (parts.length >= 4) {
+            const availableKB = parseInt(parts[3]);
+            const availableMB = availableKB / 1024;
+
+            // Require at least 100MB free space
+            if (availableMB < 100) {
+              result.success = false;
+              result.errors.push(
+                `Insufficient disk space: ${availableMB.toFixed(2)}MB available (minimum 100MB required)`,
+              );
+            } else if (availableMB < 500) {
+              result.warnings.push(`Low disk space: ${availableMB.toFixed(2)}MB available`);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      // Non-critical - just warn if we can't check disk space
+      result.warnings.push(`Could not check disk space: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Check for existing files and conflicts
+   */
+  async checkConflicts(force = false) {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      conflicts: [],
+    };
+
+    const criticalFiles = [
+      'CLAUDE.md',
+      'memory-bank.md',
+      'coordination.md',
+      '.roomodes',
+      'memory/claude-flow-data.json',
+    ];
+
+    const criticalDirs = ['.roo', '.claude', 'memory', 'coordination'];
+
+    // Check critical files
+    for (const file of criticalFiles) {
+      try {
+        const stat = await Deno.stat(`${this.workingDir}/${file}`);
+        if (stat.isFile) {
+          result.conflicts.push(file);
+          if (!force) {
+            result.success = false;
+            result.errors.push(`File already exists: ${file}`);
+          } else {
+            result.warnings.push(`File will be overwritten: ${file}`);
+          }
+        }
+      } catch {
+        // File doesn't exist - good
+      }
+    }
+
+    // Check critical directories
+    for (const dir of criticalDirs) {
+      try {
+        const stat = await Deno.stat(`${this.workingDir}/${dir}`);
+        if (stat.isDirectory) {
+          // Check if directory has important content
+          const entries = [];
+          for await (const entry of Deno.readDir(`${this.workingDir}/${dir}`)) {
+            entries.push(entry.name);
+          }
+
+          if (entries.length > 0) {
+            result.conflicts.push(`${dir}/ (${entries.length} items)`);
+            if (!force) {
+              result.warnings.push(`Directory exists with content: ${dir}/`);
+            }
+          }
+        }
+      } catch {
+        // Directory doesn't exist - good
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check for required dependencies
+   */
+  async checkDependencies() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      dependencies: {},
+    };
+
+    const dependencies = [
+      { name: 'node', command: 'node', args: ['--version'], required: true },
+      { name: 'npm', command: 'npm', args: ['--version'], required: true },
+      { name: 'git', command: 'git', args: ['--version'], required: false },
+      { name: 'npx', command: 'npx', args: ['--version'], required: true },
+    ];
+
+    for (const dep of dependencies) {
+      try {
+        const command = new Deno.Command(dep.command, {
+          args: dep.args,
+          stdout: 'piped',
+          stderr: 'piped',
+        });
+
+        const { stdout, success } = await command.output();
+
+        if (success) {
+          const version = new TextDecoder().decode(stdout).trim();
+          result.dependencies[dep.name] = {
+            available: true,
+            version,
+          };
+        } else {
+          throw new Error('Command failed');
+        }
+      } catch (error) {
+        result.dependencies[dep.name] = {
+          available: false,
+          error: error.message,
+        };
+
+        if (dep.required) {
+          result.success = false;
+          result.errors.push(`Required dependency '${dep.name}' is not available`);
+        } else {
+          result.warnings.push(`Optional dependency '${dep.name}' is not available`);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check environment variables and configuration
+   */
+  async checkEnvironment() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      environment: {},
+    };
+
+    // Check for important environment variables
+    const envVars = [
+      { name: 'HOME', required: false },
+      { name: 'PATH', required: true },
+      { name: 'PWD', required: false },
+      { name: 'CLAUDE_FLOW_DEBUG', required: false },
+    ];
+
+    for (const envVar of envVars) {
+      const value = Deno.env.get(envVar.name);
+
+      if (value) {
+        result.environment[envVar.name] = 'set';
+      } else {
+        result.environment[envVar.name] = 'not set';
+
+        if (envVar.required) {
+          result.success = false;
+          result.errors.push(`Required environment variable ${envVar.name} is not set`);
+        }
+      }
+    }
+
+    // Check if we're in a git repository
+    try {
+      const command = new Deno.Command('git', {
+        args: ['rev-parse', '--git-dir'],
+        cwd: this.workingDir,
+        stdout: 'piped',
+        stderr: 'piped',
+      });
+
+      const { success } = await command.output();
+      result.environment.gitRepo = success;
+
+      if (!success) {
+        result.warnings.push('Not in a git repository - version control recommended');
+      }
+    } catch {
+      result.environment.gitRepo = false;
+      result.warnings.push('Could not check git repository status');
+    }
+
+    return result;
+  }
+
+  /**
+   * Run all pre-initialization checks
+   */
+  async runAllChecks(options = {}) {
+    const results = {
+      permissions: await this.checkPermissions(),
+      diskSpace: await this.checkDiskSpace(),
+      conflicts: await this.checkConflicts(options.force),
+      dependencies: await this.checkDependencies(),
+      environment: await this.checkEnvironment(),
+    };
+
+    const overallSuccess = Object.values(results).every((r) => r.success);
+    const allErrors = Object.values(results).flatMap((r) => r.errors || []);
+    const allWarnings = Object.values(results).flatMap((r) => r.warnings || []);
+
+    return {
+      success: overallSuccess,
+      results,
+      errors: allErrors,
+      warnings: allWarnings,
+    };
+  }
+}