claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/init/validation/health-checker.js

@@ -1,599 +1,533 @@
-import { promises as fs } from 'fs';
+import { promises as fs } from "fs";
 // health-checker.js - System health checks for SPARC initialization
-
 export class HealthChecker {
-  constructor(workingDir) {
-    this.workingDir = workingDir;
-  }
-
-  /**
+    /**
    * Check SPARC mode availability
-   */
-  async checkModeAvailability() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      modes: {
-        total: 0,
-        available: 0,
-        unavailable: [],
-      },
-    };
-
-    try {
-      // Get expected modes
-      const expectedModes = [
-        'architect',
-        'code',
-        'tdd',
-        'spec-pseudocode',
-        'integration',
-        'debug',
-        'security-review',
-        'refinement-optimization-mode',
-        'docs-writer',
-        'devops',
-        'mcp',
-        'swarm',
-      ];
-
-      result.modes.total = expectedModes.length;
-
-      // Check each mode
-      for (const mode of expectedModes) {
-        const isAvailable = await this.checkSingleModeAvailability(mode);
-        if (isAvailable) {
-          result.modes.available++;
-        } else {
-          result.modes.unavailable.push(mode);
+   */ async checkModeAvailability() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            modes: {
+                total: 0,
+                available: 0,
+                unavailable: []
+            }
+        };
+        try {
+            // Get expected modes
+            const expectedModes = [
+                'architect',
+                'code',
+                'tdd',
+                'spec-pseudocode',
+                'integration',
+                'debug',
+                'security-review',
+                'refinement-optimization-mode',
+                'docs-writer',
+                'devops',
+                'mcp',
+                'swarm'
+            ];
+            result.modes.total = expectedModes.length;
+            // Check each mode
+            for (const mode of expectedModes){
+                const isAvailable = await this.checkSingleModeAvailability(mode);
+                if (isAvailable) {
+                    result.modes.available++;
+                } else {
+                    result.modes.unavailable.push(mode);
+                }
+            }
+            // Determine overall success
+            if (result.modes.available === 0) {
+                result.success = false;
+                result.errors.push('No SPARC modes are available');
+            } else if (result.modes.unavailable.length > 0) {
+                result.warnings.push(`${result.modes.unavailable.length} modes unavailable: ${result.modes.unavailable.join(', ')}`);
+            }
+        } catch (error) {
+            result.success = false;
+            result.errors.push(`Mode availability check failed: ${error.message}`);
         }
-      }
-
-      // Determine overall success
-      if (result.modes.available === 0) {
-        result.success = false;
-        result.errors.push('No SPARC modes are available');
-      } else if (result.modes.unavailable.length > 0) {
-        result.warnings.push(
-          `${result.modes.unavailable.length} modes unavailable: ${result.modes.unavailable.join(', ')}`,
-        );
-      }
-    } catch (error) {
-      result.success = false;
-      result.errors.push(`Mode availability check failed: ${error.message}`);
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Check template integrity
-   */
-  async checkTemplateIntegrity() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      templates: {
-        found: [],
-        missing: [],
-        corrupted: [],
-      },
-    };
-
-    try {
-      // Check for template directories
-      const templateDirs = ['.roo/templates', '.claude/commands'];
-
-      for (const dir of templateDirs) {
-        const dirPath = `${this.workingDir}/${dir}`;
-
-        try {
-          const stat = await Deno.stat(dirPath);
-          if (stat.isDirectory) {
-            const templateCheck = await this.checkTemplateDirectory(dirPath);
-            result.templates.found.push(...templateCheck.found);
-            result.templates.missing.push(...templateCheck.missing);
-            result.templates.corrupted.push(...templateCheck.corrupted);
-          }
-        } catch {
-          result.templates.missing.push(dir);
-        }
-      }
-
-      // Check core template files
-      const coreTemplates = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
-
-      for (const template of coreTemplates) {
-        const templatePath = `${this.workingDir}/${template}`;
-
+   */ async checkTemplateIntegrity() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            templates: {
+                found: [],
+                missing: [],
+                corrupted: []
+            }
+        };
         try {
-          const content = await fs.readFile(templatePath, 'utf8');
-          if (content.length < 50) {
-            result.templates.corrupted.push(template);
-          } else {
-            result.templates.found.push(template);
-          }
-        } catch {
-          result.templates.missing.push(template);
+            // Check for template directories
+            const templateDirs = [
+                '.roo/templates',
+                '.claude/commands'
+            ];
+            for (const dir of templateDirs){
+                const dirPath = `${this.workingDir}/${dir}`;
+                try {
+                    const stat = await Deno.stat(dirPath);
+                    if (stat.isDirectory) {
+                        const templateCheck = await this.checkTemplateDirectory(dirPath);
+                        result.templates.found.push(...templateCheck.found);
+                        result.templates.missing.push(...templateCheck.missing);
+                        result.templates.corrupted.push(...templateCheck.corrupted);
+                    }
+                } catch  {
+                    result.templates.missing.push(dir);
+                }
+            }
+            // Check core template files
+            const coreTemplates = [
+                'CLAUDE.md',
+                'memory-bank.md',
+                'coordination.md'
+            ];
+            for (const template of coreTemplates){
+                const templatePath = `${this.workingDir}/${template}`;
+                try {
+                    const content = await fs.readFile(templatePath, 'utf8');
+                    if (content.length < 50) {
+                        result.templates.corrupted.push(template);
+                    } else {
+                        result.templates.found.push(template);
+                    }
+                } catch  {
+                    result.templates.missing.push(template);
+                }
+            }
+            // Assess results
+            if (result.templates.corrupted.length > 0) {
+                result.success = false;
+                result.errors.push(`Corrupted templates: ${result.templates.corrupted.join(', ')}`);
+            }
+            if (result.templates.missing.length > 0) {
+                result.warnings.push(`Missing templates: ${result.templates.missing.join(', ')}`);
+            }
+        } catch (error) {
+            result.success = false;
+            result.errors.push(`Template integrity check failed: ${error.message}`);
         }
-      }
-
-      // Assess results
-      if (result.templates.corrupted.length > 0) {
-        result.success = false;
-        result.errors.push(`Corrupted templates: ${result.templates.corrupted.join(', ')}`);
-      }
-
-      if (result.templates.missing.length > 0) {
-        result.warnings.push(`Missing templates: ${result.templates.missing.join(', ')}`);
-      }
-    } catch (error) {
-      result.success = false;
-      result.errors.push(`Template integrity check failed: ${error.message}`);
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Check configuration consistency
-   */
-  async checkConfigConsistency() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      consistency: {},
-    };
-
-    try {
-      // Check consistency between .roomodes and available commands
-      const roomodesCheck = await this.checkRoomodesConsistency();
-      result.consistency.roomodes = roomodesCheck;
-      if (!roomodesCheck.consistent) {
-        result.warnings.push('Inconsistency between .roomodes and available commands');
-      }
-
-      // Check consistency between CLAUDE.md and actual setup
-      const claudeCheck = await this.checkClaudeConfigConsistency();
-      result.consistency.claude = claudeCheck;
-      if (!claudeCheck.consistent) {
-        result.warnings.push('Inconsistency between CLAUDE.md and actual setup');
-      }
-
-      // Check memory configuration consistency
-      const memoryCheck = await this.checkMemoryConsistency();
-      result.consistency.memory = memoryCheck;
-      if (!memoryCheck.consistent) {
-        result.warnings.push('Memory configuration inconsistency detected');
-      }
-    } catch (error) {
-      result.success = false;
-      result.errors.push(`Configuration consistency check failed: ${error.message}`);
+   */ async checkConfigConsistency() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            consistency: {}
+        };
+        try {
+            // Check consistency between .roomodes and available commands
+            const roomodesCheck = await this.checkRoomodesConsistency();
+            result.consistency.roomodes = roomodesCheck;
+            if (!roomodesCheck.consistent) {
+                result.warnings.push('Inconsistency between .roomodes and available commands');
+            }
+            // Check consistency between CLAUDE.md and actual setup
+            const claudeCheck = await this.checkClaudeConfigConsistency();
+            result.consistency.claude = claudeCheck;
+            if (!claudeCheck.consistent) {
+                result.warnings.push('Inconsistency between CLAUDE.md and actual setup');
+            }
+            // Check memory configuration consistency
+            const memoryCheck = await this.checkMemoryConsistency();
+            result.consistency.memory = memoryCheck;
+            if (!memoryCheck.consistent) {
+                result.warnings.push('Memory configuration inconsistency detected');
+            }
+        } catch (error) {
+            result.success = false;
+            result.errors.push(`Configuration consistency check failed: ${error.message}`);
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Check system resources
-   */
-  async checkSystemResources() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      resources: {},
-    };
-
-    try {
-      // Check disk space
-      const diskCheck = await this.checkDiskSpace();
-      result.resources.disk = diskCheck;
-      if (!diskCheck.adequate) {
-        result.warnings.push('Low disk space detected');
-      }
-
-      // Check memory usage
-      const memoryCheck = await this.checkMemoryUsage();
-      result.resources.memory = memoryCheck;
-      if (!memoryCheck.adequate) {
-        result.warnings.push('High memory usage detected');
-      }
-
-      // Check file descriptors
-      const fdCheck = await this.checkFileDescriptors();
-      result.resources.fileDescriptors = fdCheck;
-      if (!fdCheck.adequate) {
-        result.warnings.push('Many open file descriptors');
-      }
-
-      // Check process limits
-      const processCheck = await this.checkProcessLimits();
-      result.resources.processes = processCheck;
-      if (!processCheck.adequate) {
-        result.warnings.push('Process limits may affect operation');
-      }
-    } catch (error) {
-      result.warnings.push(`System resource check failed: ${error.message}`);
+   */ async checkSystemResources() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            resources: {}
+        };
+        try {
+            // Check disk space
+            const diskCheck = await this.checkDiskSpace();
+            result.resources.disk = diskCheck;
+            if (!diskCheck.adequate) {
+                result.warnings.push('Low disk space detected');
+            }
+            // Check memory usage
+            const memoryCheck = await this.checkMemoryUsage();
+            result.resources.memory = memoryCheck;
+            if (!memoryCheck.adequate) {
+                result.warnings.push('High memory usage detected');
+            }
+            // Check file descriptors
+            const fdCheck = await this.checkFileDescriptors();
+            result.resources.fileDescriptors = fdCheck;
+            if (!fdCheck.adequate) {
+                result.warnings.push('Many open file descriptors');
+            }
+            // Check process limits
+            const processCheck = await this.checkProcessLimits();
+            result.resources.processes = processCheck;
+            if (!processCheck.adequate) {
+                result.warnings.push('Process limits may affect operation');
+            }
+        } catch (error) {
+            result.warnings.push(`System resource check failed: ${error.message}`);
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  /**
+    /**
    * Run comprehensive health diagnostics
-   */
-  async runDiagnostics() {
-    const result = {
-      success: true,
-      errors: [],
-      warnings: [],
-      diagnostics: {},
-      timestamp: new Date().toISOString(),
-    };
-
-    try {
-      // File system health
-      const fsHealth = await this.checkFileSystemHealth();
-      result.diagnostics.filesystem = fsHealth;
-      if (!fsHealth.healthy) {
-        result.success = false;
-        result.errors.push(...fsHealth.errors);
-      }
-
-      // Process health
-      const processHealth = await this.checkProcessHealth();
-      result.diagnostics.processes = processHealth;
-      if (!processHealth.healthy) {
-        result.warnings.push(...processHealth.warnings);
-      }
-
-      // Network health (for external dependencies)
-      const networkHealth = await this.checkNetworkHealth();
-      result.diagnostics.network = networkHealth;
-      if (!networkHealth.healthy) {
-        result.warnings.push(...networkHealth.warnings);
-      }
-
-      // Integration health
-      const integrationHealth = await this.checkIntegrationHealth();
-      result.diagnostics.integration = integrationHealth;
-      if (!integrationHealth.healthy) {
-        result.warnings.push(...integrationHealth.warnings);
-      }
-    } catch (error) {
-      result.success = false;
-      result.errors.push(`Health diagnostics failed: ${error.message}`);
+   */ async runDiagnostics() {
+        const result = {
+            success: true,
+            errors: [],
+            warnings: [],
+            diagnostics: {},
+            timestamp: new Date().toISOString()
+        };
+        try {
+            // File system health
+            const fsHealth = await this.checkFileSystemHealth();
+            result.diagnostics.filesystem = fsHealth;
+            if (!fsHealth.healthy) {
+                result.success = false;
+                result.errors.push(...fsHealth.errors);
+            }
+            // Process health
+            const processHealth = await this.checkProcessHealth();
+            result.diagnostics.processes = processHealth;
+            if (!processHealth.healthy) {
+                result.warnings.push(...processHealth.warnings);
+            }
+            // Network health (for external dependencies)
+            const networkHealth = await this.checkNetworkHealth();
+            result.diagnostics.network = networkHealth;
+            if (!networkHealth.healthy) {
+                result.warnings.push(...networkHealth.warnings);
+            }
+            // Integration health
+            const integrationHealth = await this.checkIntegrationHealth();
+            result.diagnostics.integration = integrationHealth;
+            if (!integrationHealth.healthy) {
+                result.warnings.push(...integrationHealth.warnings);
+            }
+        } catch (error) {
+            result.success = false;
+            result.errors.push(`Health diagnostics failed: ${error.message}`);
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  // Helper methods
-
-  async checkSingleModeAvailability(mode) {
-    try {
-      // Check if mode exists in .roomodes
-      const roomodesPath = `${this.workingDir}/.roomodes`;
-      const content = await fs.readFile(roomodesPath, 'utf8');
-      const config = JSON.parse(content);
-
-      return !!(config.modes && config.modes[mode]);
-    } catch {
-      return false;
+    // Helper methods
+    async checkSingleModeAvailability(mode) {
+        try {
+            // Check if mode exists in .roomodes
+            const roomodesPath = `${this.workingDir}/.roomodes`;
+            const content = await fs.readFile(roomodesPath, 'utf8');
+            const config = JSON.parse(content);
+            return !!(config.modes && config.modes[mode]);
+        } catch  {
+            return false;
+        }
     }
-  }
-
-  async checkTemplateDirectory(dirPath) {
-    const result = {
-      found: [],
-      missing: [],
-      corrupted: [],
-    };
-
-    try {
-      for await (const entry of Deno.readDir(dirPath)) {
-        if (entry.isFile) {
-          const filePath = `${dirPath}/${entry.name}`;
-
-          try {
-            const stat = await Deno.stat(filePath);
-            if (stat.size === 0) {
-              result.corrupted.push(entry.name);
-            } else {
-              result.found.push(entry.name);
+    async checkTemplateDirectory(dirPath) {
+        const result = {
+            found: [],
+            missing: [],
+            corrupted: []
+        };
+        try {
+            for await (const entry of Deno.readDir(dirPath)){
+                if (entry.isFile) {
+                    const filePath = `${dirPath}/${entry.name}`;
+                    try {
+                        const stat = await Deno.stat(filePath);
+                        if (stat.size === 0) {
+                            result.corrupted.push(entry.name);
+                        } else {
+                            result.found.push(entry.name);
+                        }
+                    } catch  {
+                        result.corrupted.push(entry.name);
+                    }
+                }
             }
-          } catch {
-            result.corrupted.push(entry.name);
-          }
+        } catch  {
+        // Directory not accessible
         }
-      }
-    } catch {
-      // Directory not accessible
+        return result;
     }
-
-    return result;
-  }
-
-  async checkRoomodesConsistency() {
-    const result = {
-      consistent: true,
-      issues: [],
-    };
-
-    try {
-      // Compare .roomodes with slash commands
-      const roomodesPath = `${this.workingDir}/.roomodes`;
-      const content = await fs.readFile(roomodesPath, 'utf8');
-      const config = JSON.parse(content);
-
-      if (config.modes) {
-        const commandsDir = `${this.workingDir}/.claude/commands`;
-
+    async checkRoomodesConsistency() {
+        const result = {
+            consistent: true,
+            issues: []
+        };
         try {
-          const commandFiles = [];
-          for await (const entry of Deno.readDir(commandsDir)) {
-            if (entry.isFile && entry.name.endsWith('.js')) {
-              commandFiles.push(entry.name.replace('.js', ''));
+            // Compare .roomodes with slash commands
+            const roomodesPath = `${this.workingDir}/.roomodes`;
+            const content = await fs.readFile(roomodesPath, 'utf8');
+            const config = JSON.parse(content);
+            if (config.modes) {
+                const commandsDir = `${this.workingDir}/.claude/commands`;
+                try {
+                    const commandFiles = [];
+                    for await (const entry of Deno.readDir(commandsDir)){
+                        if (entry.isFile && entry.name.endsWith('.js')) {
+                            commandFiles.push(entry.name.replace('.js', ''));
+                        }
+                    }
+                    const modeNames = Object.keys(config.modes);
+                    for (const mode of modeNames){
+                        if (!commandFiles.some((cmd)=>cmd.includes(mode))) {
+                            result.consistent = false;
+                            result.issues.push(`Mode ${mode} has no corresponding command`);
+                        }
+                    }
+                } catch  {
+                    result.consistent = false;
+                    result.issues.push('Cannot access commands directory');
+                }
             }
-          }
-
-          const modeNames = Object.keys(config.modes);
-          for (const mode of modeNames) {
-            if (!commandFiles.some((cmd) => cmd.includes(mode))) {
-              result.consistent = false;
-              result.issues.push(`Mode ${mode} has no corresponding command`);
+        } catch  {
+            result.consistent = false;
+            result.issues.push('Cannot read .roomodes file');
+        }
+        return result;
+    }
+    async checkClaudeConfigConsistency() {
+        const result = {
+            consistent: true,
+            issues: []
+        };
+        try {
+            const claudePath = `${this.workingDir}/CLAUDE.md`;
+            const content = await fs.readFile(claudePath, 'utf8');
+            // Check if mentioned commands exist
+            const mentionedCommands = [
+                'claude-flow-novice sparc',
+                'npm run build',
+                'npm run test'
+            ];
+            for (const command of mentionedCommands){
+                if (content.includes(command)) {
+                    // Check if the command is actually available
+                    const parts = command.split(' ');
+                    if (parts[0] === 'claude-flow') {
+                        const executablePath = `${this.workingDir}/claude-flow`;
+                        try {
+                            await Deno.stat(executablePath);
+                        } catch  {
+                            result.consistent = false;
+                            result.issues.push(`Command ${command} mentioned but executable not found`);
+                        }
+                    }
+                }
             }
-          }
-        } catch {
-          result.consistent = false;
-          result.issues.push('Cannot access commands directory');
+        } catch  {
+            result.consistent = false;
+            result.issues.push('Cannot read CLAUDE.md');
         }
-      }
-    } catch {
-      result.consistent = false;
-      result.issues.push('Cannot read .roomodes file');
+        return result;
     }
-
-    return result;
-  }
-
-  async checkClaudeConfigConsistency() {
-    const result = {
-      consistent: true,
-      issues: [],
-    };
-
-    try {
-      const claudePath = `${this.workingDir}/CLAUDE.md`;
-      const content = await fs.readFile(claudePath, 'utf8');
-
-      // Check if mentioned commands exist
-      const mentionedCommands = ['claude-flow-novice sparc', 'npm run build', 'npm run test'];
-
-      for (const command of mentionedCommands) {
-        if (content.includes(command)) {
-          // Check if the command is actually available
-          const parts = command.split(' ');
-          if (parts[0] === 'claude-flow') {
-            const executablePath = `${this.workingDir}/claude-flow`;
-            try {
-              await Deno.stat(executablePath);
-            } catch {
-              result.consistent = false;
-              result.issues.push(`Command ${command} mentioned but executable not found`);
+    async checkMemoryConsistency() {
+        const result = {
+            consistent: true,
+            issues: []
+        };
+        try {
+            // Check if memory structure matches documentation
+            const memoryDataPath = `${this.workingDir}/memory/claude-flow-data.json`;
+            const data = JSON.parse(await fs.readFile(memoryDataPath, 'utf8'));
+            // Basic structure validation
+            if (!data.agents || !data.tasks) {
+                result.consistent = false;
+                result.issues.push('Memory data structure incomplete');
+            }
+            // Check directory structure
+            const expectedDirs = [
+                'agents',
+                'sessions'
+            ];
+            for (const dir of expectedDirs){
+                try {
+                    await Deno.stat(`${this.workingDir}/memory/${dir}`);
+                } catch  {
+                    result.consistent = false;
+                    result.issues.push(`Memory directory missing: ${dir}`);
+                }
             }
-          }
+        } catch  {
+            result.consistent = false;
+            result.issues.push('Cannot validate memory structure');
         }
-      }
-    } catch {
-      result.consistent = false;
-      result.issues.push('Cannot read CLAUDE.md');
+        return result;
     }
-
-    return result;
-  }
-
-  async checkMemoryConsistency() {
-    const result = {
-      consistent: true,
-      issues: [],
-    };
-
-    try {
-      // Check if memory structure matches documentation
-      const memoryDataPath = `${this.workingDir}/memory/claude-flow-data.json`;
-      const data = JSON.parse(await fs.readFile(memoryDataPath, 'utf8'));
-
-      // Basic structure validation
-      if (!data.agents || !data.tasks) {
-        result.consistent = false;
-        result.issues.push('Memory data structure incomplete');
-      }
-
-      // Check directory structure
-      const expectedDirs = ['agents', 'sessions'];
-      for (const dir of expectedDirs) {
+    async checkDiskSpace() {
+        const result = {
+            adequate: true,
+            available: 0,
+            used: 0
+        };
         try {
-          await Deno.stat(`${this.workingDir}/memory/${dir}`);
-        } catch {
-          result.consistent = false;
-          result.issues.push(`Memory directory missing: ${dir}`);
+            const command = new Deno.Command('df', {
+                args: [
+                    '-k',
+                    this.workingDir
+                ],
+                stdout: '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 parts = lines[1].split(/\s+/);
+                    if (parts.length >= 4) {
+                        result.available = parseInt(parts[3]) / 1024; // MB
+                        result.used = parseInt(parts[2]) / 1024; // MB
+                        result.adequate = result.available > 100; // At least 100MB
+                    }
+                }
+            }
+        } catch  {
+            // Can't check - assume adequate
+            result.adequate = true;
         }
-      }
-    } catch {
-      result.consistent = false;
-      result.issues.push('Cannot validate memory structure');
+        return result;
     }
-
-    return result;
-  }
-
-  async checkDiskSpace() {
-    const result = {
-      adequate: true,
-      available: 0,
-      used: 0,
-    };
-
-    try {
-      const command = new Deno.Command('df', {
-        args: ['-k', this.workingDir],
-        stdout: '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 parts = lines[1].split(/\s+/);
-          if (parts.length >= 4) {
-            result.available = parseInt(parts[3]) / 1024; // MB
-            result.used = parseInt(parts[2]) / 1024; // MB
-            result.adequate = result.available > 100; // At least 100MB
-          }
+    async checkMemoryUsage() {
+        const result = {
+            adequate: true,
+            available: 0,
+            used: 0
+        };
+        try {
+            // This is a simplified check - could be enhanced
+            const command = new Deno.Command('free', {
+                args: [
+                    '-m'
+                ],
+                stdout: 'piped'
+            });
+            const { stdout, success } = await command.output();
+            if (success) {
+                const output = new TextDecoder().decode(stdout);
+                const lines = output.trim().split('\n');
+                for (const line of lines){
+                    if (line.startsWith('Mem:')) {
+                        const parts = line.split(/\s+/);
+                        if (parts.length >= 3) {
+                            result.available = parseInt(parts[6] || parts[3]); // Available
+                            result.used = parseInt(parts[2]); // Used
+                            result.adequate = result.available > 100; // At least 100MB
+                        }
+                        break;
+                    }
+                }
+            }
+        } catch  {
+            // Can't check - assume adequate
+            result.adequate = true;
         }
-      }
-    } catch {
-      // Can't check - assume adequate
-      result.adequate = true;
+        return result;
     }
-
-    return result;
-  }
-
-  async checkMemoryUsage() {
-    const result = {
-      adequate: true,
-      available: 0,
-      used: 0,
-    };
-
-    try {
-      // This is a simplified check - could be enhanced
-      const command = new Deno.Command('free', {
-        args: ['-m'],
-        stdout: 'piped',
-      });
-
-      const { stdout, success } = await command.output();
-
-      if (success) {
-        const output = new TextDecoder().decode(stdout);
-        const lines = output.trim().split('\n');
-
-        for (const line of lines) {
-          if (line.startsWith('Mem:')) {
-            const parts = line.split(/\s+/);
-            if (parts.length >= 3) {
-              result.available = parseInt(parts[6] || parts[3]); // Available
-              result.used = parseInt(parts[2]); // Used
-              result.adequate = result.available > 100; // At least 100MB
+    async checkFileDescriptors() {
+        const result = {
+            adequate: true,
+            open: 0,
+            limit: 0
+        };
+        try {
+            // Check current process file descriptors
+            const command = new Deno.Command('sh', {
+                args: [
+                    '-c',
+                    'lsof -p $$ | wc -l'
+                ],
+                stdout: 'piped'
+            });
+            const { stdout, success } = await command.output();
+            if (success) {
+                const count = parseInt(new TextDecoder().decode(stdout).trim());
+                result.open = count;
+                result.adequate = count < 100; // Arbitrary threshold
             }
-            break;
-          }
+        } catch  {
+            // Can't check - assume adequate
+            result.adequate = true;
         }
-      }
-    } catch {
-      // Can't check - assume adequate
-      result.adequate = true;
+        return result;
+    }
+    async checkProcessLimits() {
+        const result = {
+            adequate: true,
+            limits: {}
+        };
+        try {
+            const command = new Deno.Command('ulimit', {
+                args: [
+                    '-a'
+                ],
+                stdout: 'piped'
+            });
+            const { stdout, success } = await command.output();
+            if (success) {
+                const output = new TextDecoder().decode(stdout);
+                // Parse ulimit output for important limits
+                result.adequate = !output.includes('0'); // Very basic check
+            }
+        } catch  {
+            // Can't check - assume adequate
+            result.adequate = true;
+        }
+        return result;
+    }
+    async checkFileSystemHealth() {
+        return {
+            healthy: true,
+            errors: [],
+            readWrite: true,
+            permissions: true
+        };
+    }
+    async checkProcessHealth() {
+        return {
+            healthy: true,
+            warnings: [],
+            processes: []
+        };
+    }
+    async checkNetworkHealth() {
+        return {
+            healthy: true,
+            warnings: [],
+            connectivity: true
+        };
     }
-
-    return result;
-  }
-
-  async checkFileDescriptors() {
-    const result = {
-      adequate: true,
-      open: 0,
-      limit: 0,
-    };
-
-    try {
-      // Check current process file descriptors
-      const command = new Deno.Command('sh', {
-        args: ['-c', 'lsof -p $$ | wc -l'],
-        stdout: 'piped',
-      });
-
-      const { stdout, success } = await command.output();
-
-      if (success) {
-        const count = parseInt(new TextDecoder().decode(stdout).trim());
-        result.open = count;
-        result.adequate = count < 100; // Arbitrary threshold
-      }
-    } catch {
-      // Can't check - assume adequate
-      result.adequate = true;
+    async checkIntegrationHealth() {
+        return {
+            healthy: true,
+            warnings: [],
+            integrations: {}
+        };
     }
-
-    return result;
-  }
-
-  async checkProcessLimits() {
-    const result = {
-      adequate: true,
-      limits: {},
-    };
-
-    try {
-      const command = new Deno.Command('ulimit', {
-        args: ['-a'],
-        stdout: 'piped',
-      });
-
-      const { stdout, success } = await command.output();
-
-      if (success) {
-        const output = new TextDecoder().decode(stdout);
-        // Parse ulimit output for important limits
-        result.adequate = !output.includes('0'); // Very basic check
-      }
-    } catch {
-      // Can't check - assume adequate
-      result.adequate = true;
+    constructor(workingDir){
+        this.workingDir = workingDir;
     }
-
-    return result;
-  }
-
-  async checkFileSystemHealth() {
-    return {
-      healthy: true,
-      errors: [],
-      readWrite: true,
-      permissions: true,
-    };
-  }
-
-  async checkProcessHealth() {
-    return {
-      healthy: true,
-      warnings: [],
-      processes: [],
-    };
-  }
-
-  async checkNetworkHealth() {
-    return {
-      healthy: true,
-      warnings: [],
-      connectivity: true,
-    };
-  }
-
-  async checkIntegrationHealth() {
-    return {
-      healthy: true,
-      warnings: [],
-      integrations: {},
-    };
-  }
 }