claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,533 +1,599 @@
-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);
-                }
-            }
-            // 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}`);
+   */
+  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);
         }
-        return result;
+      }
+
+      // 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;
+  }
+
+  /**
    * Check template integrity
-   */ async checkTemplateIntegrity() {
-        const result = {
-            success: true,
-            errors: [],
-            warnings: [],
-            templates: {
-                found: [],
-                missing: [],
-                corrupted: []
-            }
-        };
+   */
+  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 {
-            // 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}`);
+          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);
         }
-        return result;
-    }
-    /**
-   * Check configuration consistency
-   */ async checkConfigConsistency() {
-        const result = {
-            success: true,
-            errors: [],
-            warnings: [],
-            consistency: {}
-        };
+      }
+
+      // Check core template files
+      const coreTemplates = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
+
+      for (const template of coreTemplates) {
+        const templatePath = `${this.workingDir}/${template}`;
+
         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}`);
+          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);
         }
-        return result;
+      }
+
+      // 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;
+  }
+
+  /**
+   * 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}`);
     }
-    /**
+
+    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}`);
-        }
-        return result;
+   */
+  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;
+  }
+
+  /**
    * 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}`);
-        }
-        return result;
+   */
+  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}`);
     }
-    // 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;
-        }
+
+    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;
     }
-    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);
-                    }
-                }
+  }
+
+  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  {
-        // Directory not accessible
+          } catch {
+            result.corrupted.push(entry.name);
+          }
         }
-        return result;
+      }
+    } catch {
+      // Directory not accessible
     }
-    async checkRoomodesConsistency() {
-        const result = {
-            consistent: true,
-            issues: []
-        };
+
+    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`;
+
         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`;
-                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 commandFiles = [];
+          for await (const entry of Deno.readDir(commandsDir)) {
+            if (entry.isFile && entry.name.endsWith('.js')) {
+              commandFiles.push(entry.name.replace('.js', ''));
             }
-        } 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`);
-                        }
-                    }
-                }
+          }
+
+          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 CLAUDE.md');
+          }
+        } catch {
+          result.consistent = false;
+          result.issues.push('Cannot access commands directory');
         }
-        return result;
+      }
+    } catch {
+      result.consistent = false;
+      result.issues.push('Cannot read .roomodes file');
     }
-    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}`);
-                }
+
+    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 validate memory structure');
+          }
         }
-        return result;
+      }
+    } catch {
+      result.consistent = false;
+      result.issues.push('Cannot read CLAUDE.md');
     }
-    async checkDiskSpace() {
-        const result = {
-            adequate: true,
-            available: 0,
-            used: 0
-        };
+
+    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) {
         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
-                    }
-                }
-            }
-        } catch  {
-            // Can't check - assume adequate
-            result.adequate = true;
+          await Deno.stat(`${this.workingDir}/memory/${dir}`);
+        } catch {
+          result.consistent = false;
+          result.issues.push(`Memory directory missing: ${dir}`);
         }
-        return result;
+      }
+    } catch {
+      result.consistent = false;
+      result.issues.push('Cannot validate memory structure');
     }
-    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;
+
+    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
+          }
         }
-        return result;
+      }
+    } catch {
+      // Can't check - assume adequate
+      result.adequate = true;
     }
-    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
+
+    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
             }
-        } catch  {
-            // Can't check - assume adequate
-            result.adequate = true;
+            break;
+          }
         }
-        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
-        };
+      }
+    } catch {
+      // Can't check - assume adequate
+      result.adequate = true;
     }
-    async checkIntegrationHealth() {
-        return {
-            healthy: true,
-            warnings: [],
-            integrations: {}
-        };
+
+    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;
     }
-    constructor(workingDir){
-        this.workingDir = workingDir;
+
+    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,
+    };
+  }
+
+  async checkIntegrationHealth() {
+    return {
+      healthy: true,
+      warnings: [],
+      integrations: {},
+    };
+  }
 }