@codihaus/claude-skills 1.0.0

package/src/utils/deps.js

@@ -0,0 +1,599 @@
+/**
+ * Dependency Checker
+ *
+ * Checks for required global tools and project dependencies.
+ * Handles macOS and Linux differences.
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import os from 'os';
+
+/**
+ * Detect OS for install hints
+ */
+function getOS() {
+  const platform = os.platform();
+  if (platform === 'darwin') return 'macos';
+  if (platform === 'linux') {
+    // Try to detect distro
+    try {
+      const release = fs.readFileSync('/etc/os-release', 'utf-8');
+      if (release.includes('Ubuntu') || release.includes('Debian')) return 'debian';
+      if (release.includes('Fedora') || release.includes('Red Hat') || release.includes('CentOS')) return 'redhat';
+      if (release.includes('Arch')) return 'arch';
+    } catch (e) {
+      // Fallback
+    }
+    return 'linux';
+  }
+  return 'unknown';
+}
+
+/**
+ * Get install command based on OS
+ */
+function getInstallHint(tool, osType) {
+  const hints = {
+    node: {
+      macos: 'brew install node  OR  https://nodejs.org/',
+      debian: 'sudo apt install nodejs npm  OR  https://nodejs.org/',
+      redhat: 'sudo dnf install nodejs npm  OR  https://nodejs.org/',
+      arch: 'sudo pacman -S nodejs npm',
+      linux: 'https://nodejs.org/ (use official installer)',
+      unknown: 'https://nodejs.org/'
+    },
+    git: {
+      macos: 'xcode-select --install  OR  brew install git',
+      debian: 'sudo apt install git',
+      redhat: 'sudo dnf install git',
+      arch: 'sudo pacman -S git',
+      linux: 'sudo apt install git  OR  sudo dnf install git',
+      unknown: 'https://git-scm.com/'
+    },
+    python3: {
+      macos: 'brew install python3  OR  https://python.org/',
+      debian: 'sudo apt install python3 python3-pip',
+      redhat: 'sudo dnf install python3 python3-pip',
+      arch: 'sudo pacman -S python python-pip',
+      linux: 'sudo apt install python3 python3-pip',
+      unknown: 'https://python.org/'
+    },
+    pip3: {
+      macos: 'python3 -m ensurepip  OR  brew install python3',
+      debian: 'sudo apt install python3-pip',
+      redhat: 'sudo dnf install python3-pip',
+      arch: 'sudo pacman -S python-pip',
+      linux: 'sudo apt install python3-pip',
+      unknown: 'python3 -m ensurepip'
+    },
+    jq: {
+      macos: 'brew install jq',
+      debian: 'sudo apt install jq',
+      redhat: 'sudo dnf install jq',
+      arch: 'sudo pacman -S jq',
+      linux: 'sudo apt install jq  OR  sudo dnf install jq',
+      unknown: 'https://stedolan.github.io/jq/download/'
+    },
+    gh: {
+      macos: 'brew install gh',
+      debian: 'sudo apt install gh  OR  https://cli.github.com/',
+      redhat: 'sudo dnf install gh',
+      arch: 'sudo pacman -S github-cli',
+      linux: 'https://cli.github.com/',
+      unknown: 'https://cli.github.com/'
+    },
+    mmdc: {
+      macos: 'npm install -g @mermaid-js/mermaid-cli',
+      debian: 'npm install -g @mermaid-js/mermaid-cli',
+      redhat: 'npm install -g @mermaid-js/mermaid-cli',
+      arch: 'npm install -g @mermaid-js/mermaid-cli',
+      linux: 'npm install -g @mermaid-js/mermaid-cli',
+      unknown: 'npm install -g @mermaid-js/mermaid-cli'
+    },
+    tree: {
+      macos: 'brew install tree',
+      debian: 'sudo apt install tree',
+      redhat: 'sudo dnf install tree',
+      arch: 'sudo pacman -S tree',
+      linux: 'sudo apt install tree',
+      unknown: 'https://mama.indstate.edu/users/ice/tree/'
+    },
+    scc: {
+      macos: 'brew install scc  OR  go install github.com/boyter/scc/v3@latest',
+      debian: 'go install github.com/boyter/scc/v3@latest',
+      redhat: 'go install github.com/boyter/scc/v3@latest',
+      arch: 'yay -S scc  OR  go install github.com/boyter/scc/v3@latest',
+      linux: 'go install github.com/boyter/scc/v3@latest',
+      unknown: 'https://github.com/boyter/scc'
+    },
+    rg: {
+      macos: 'brew install ripgrep',
+      debian: 'sudo apt install ripgrep',
+      redhat: 'sudo dnf install ripgrep',
+      arch: 'sudo pacman -S ripgrep',
+      linux: 'sudo apt install ripgrep  OR  cargo install ripgrep',
+      unknown: 'https://github.com/BurntSushi/ripgrep'
+    }
+  };
+
+  return hints[tool]?.[osType] || hints[tool]?.unknown || 'See documentation';
+}
+
+const osType = getOS();
+
+/**
+ * Global dependencies required for skills to work
+ */
+export const GLOBAL_DEPS = {
+  required: [
+    {
+      name: 'node',
+      command: 'node --version',
+      minVersion: '18.0.0',
+      get installHint() { return getInstallHint('node', osType); },
+      purpose: 'Runtime for CLI and scripts',
+      usedBy: ['CLI', 'npm packages']
+    },
+    {
+      name: 'git',
+      command: 'git --version',
+      get installHint() { return getInstallHint('git', osType); },
+      purpose: 'Version control, git operations',
+      usedBy: ['/dev-review', '/dev-changelog']
+    }
+  ],
+  recommended: [
+    {
+      name: 'python3',
+      command: 'python3 --version',
+      minVersion: '3.8.0',
+      get installHint() { return getInstallHint('python3', osType); },
+      purpose: 'Required for Python scripts',
+      usedBy: ['/utils/gemini', '/debrief (questionnaire)']
+    },
+    {
+      name: 'pip3',
+      command: 'pip3 --version',
+      alternateCommand: 'python3 -m pip --version',
+      get installHint() { return getInstallHint('pip3', osType); },
+      purpose: 'Install Python packages',
+      usedBy: ['/utils/gemini', '/debrief']
+    },
+    {
+      name: 'jq',
+      command: 'jq --version',
+      get installHint() { return getInstallHint('jq', osType); },
+      purpose: 'JSON processing for docs-graph',
+      usedBy: ['/utils/docs-graph', '/dev-scout']
+    }
+  ],
+  optional: [
+    {
+      name: 'gh',
+      command: 'gh --version',
+      get installHint() { return getInstallHint('gh', osType); },
+      purpose: 'GitHub CLI for PR creation',
+      usedBy: ['PR creation', 'GitHub operations']
+    },
+    {
+      name: 'mmdc',
+      command: 'mmdc --version',
+      get installHint() { return getInstallHint('mmdc', osType); },
+      purpose: 'Mermaid CLI for diagram rendering',
+      usedBy: ['/utils/diagram']
+    },
+    {
+      name: 'tree',
+      command: 'tree --version',
+      get installHint() { return getInstallHint('tree', osType); },
+      purpose: 'Directory visualization (has fallback)',
+      usedBy: ['/dev-scout']
+    },
+    {
+      name: 'scc',
+      command: 'scc --version',
+      get installHint() { return getInstallHint('scc', osType); },
+      purpose: 'Fast code statistics - lines, languages (has fallback)',
+      usedBy: ['/dev-scout']
+    },
+    {
+      name: 'rg',
+      command: 'rg --version',
+      get installHint() { return getInstallHint('rg', osType); },
+      purpose: 'Ripgrep for faster searching (has fallback)',
+      usedBy: ['/dev-scout']
+    }
+  ]
+};
+
+/**
+ * Python packages needed
+ */
+export const PYTHON_DEPS = [
+  {
+    name: 'openpyxl',
+    importName: 'openpyxl',
+    installCmd: 'pip3 install openpyxl',
+    purpose: 'Excel questionnaire generation',
+    usedBy: ['/debrief']
+  },
+  {
+    name: 'google-generativeai',
+    importName: 'google.generativeai',
+    installCmd: 'pip3 install google-generativeai',
+    purpose: 'Gemini API for large codebase scanning',
+    usedBy: ['/utils/gemini']
+  }
+];
+
+/**
+ * Project npm dependencies
+ */
+export const PROJECT_DEPS = {
+  forTesting: [
+    {
+      name: '@playwright/test',
+      purpose: 'UI testing with /dev-test',
+      usedBy: ['/dev-test', '/dev-coding-frontend']
+    }
+  ],
+  optional: [
+    {
+      name: '@mermaid-js/mermaid-cli',
+      purpose: 'Diagram rendering (optional)',
+      usedBy: ['/utils/diagram'],
+      global: true
+    }
+  ]
+};
+
+/**
+ * Check if a command exists and optionally verify version
+ */
+export function checkCommand(cmd, alternateCmd = null, minVersion = null) {
+  const commands = alternateCmd ? [cmd, alternateCmd] : [cmd];
+
+  for (const command of commands) {
+    try {
+      const output = execSync(command, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      if (minVersion) {
+        const versionMatch = output.match(/(\d+\.\d+\.\d+)/);
+        if (versionMatch) {
+          const version = versionMatch[1];
+          if (compareVersions(version, minVersion) < 0) {
+            return { found: true, version, outdated: true, minVersion };
+          }
+          return { found: true, version, outdated: false };
+        }
+      }
+
+      return { found: true, version: output.trim().split('\n')[0] };
+    } catch (e) {
+      // Try next command
+    }
+  }
+
+  return { found: false };
+}
+
+/**
+ * Check if a Python package is installed
+ */
+export function checkPythonPackage(importName) {
+  try {
+    execSync(`python3 -c "import ${importName}"`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return { installed: true };
+  } catch (e) {
+    return { installed: false };
+  }
+}
+
+/**
+ * Compare semantic versions
+ */
+function compareVersions(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Check all global dependencies
+ */
+export async function checkGlobalDeps(options = {}) {
+  const results = {
+    os: osType,
+    required: [],
+    recommended: [],
+    optional: [],
+    python: [],
+    hasErrors: false,
+    hasWarnings: false
+  };
+
+  // Check required
+  for (const dep of GLOBAL_DEPS.required) {
+    const result = checkCommand(dep.command, dep.alternateCommand, dep.minVersion);
+    results.required.push({
+      ...dep,
+      ...result,
+      status: result.found && !result.outdated ? 'ok' : 'error'
+    });
+    if (!result.found || result.outdated) {
+      results.hasErrors = true;
+    }
+  }
+
+  // Check recommended
+  for (const dep of GLOBAL_DEPS.recommended) {
+    const result = checkCommand(dep.command, dep.alternateCommand, dep.minVersion);
+    results.recommended.push({
+      ...dep,
+      ...result,
+      status: result.found && !result.outdated ? 'ok' : 'warning'
+    });
+    if (!result.found || result.outdated) {
+      results.hasWarnings = true;
+    }
+  }
+
+  // Check optional
+  for (const dep of GLOBAL_DEPS.optional) {
+    const result = checkCommand(dep.command, dep.alternateCommand);
+    results.optional.push({
+      ...dep,
+      ...result,
+      status: result.found ? 'ok' : 'info'
+    });
+  }
+
+  // Check Python packages (only if python3 is available)
+  const hasPython = results.required.concat(results.recommended)
+    .find(d => d.name === 'python3')?.found;
+
+  if (hasPython) {
+    for (const pkg of PYTHON_DEPS) {
+      const result = checkPythonPackage(pkg.importName);
+      results.python.push({
+        ...pkg,
+        ...result,
+        status: result.installed ? 'ok' : 'warning'
+      });
+      if (!result.installed) {
+        results.hasWarnings = true;
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check project dependencies
+ */
+export async function checkProjectDeps(projectPath) {
+  const results = {
+    npm: [],
+    missing: [],
+    hasErrors: false
+  };
+
+  const packageJsonPath = path.join(projectPath, 'package.json');
+
+  // Check if package.json exists
+  if (!await fs.pathExists(packageJsonPath)) {
+    results.noPackageJson = true;
+    return results;
+  }
+
+  const packageJson = await fs.readJson(packageJsonPath);
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+
+  // Check for required npm deps
+  for (const dep of PROJECT_DEPS.forTesting) {
+    const installed = !!allDeps[dep.name];
+    results.npm.push({
+      ...dep,
+      installed,
+      status: installed ? 'ok' : 'missing'
+    });
+    if (!installed) {
+      results.missing.push(dep);
+    }
+  }
+
+  results.hasErrors = results.missing.length > 0;
+  return results;
+}
+
+/**
+ * Print dependency check results
+ */
+export function printDepsReport(globalResults, projectResults = null) {
+  console.log(chalk.bold(`\nSystem: ${globalResults.os}`));
+  console.log('─'.repeat(50));
+
+  // Required
+  console.log(chalk.cyan('\nRequired (must have):'));
+  for (const dep of globalResults.required) {
+    const icon = dep.status === 'ok' ? chalk.green('✓') : chalk.red('✗');
+    const version = dep.version ? chalk.gray(` (${dep.version.substring(0, 30)})`) : '';
+    console.log(`  ${icon} ${dep.name}${version}`);
+    if (dep.status !== 'ok') {
+      console.log(chalk.yellow(`    → ${dep.installHint}`));
+    }
+  }
+
+  // Recommended
+  console.log(chalk.cyan('\nRecommended (for full functionality):'));
+  for (const dep of globalResults.recommended) {
+    const icon = dep.status === 'ok' ? chalk.green('✓') : chalk.yellow('○');
+    const version = dep.version ? chalk.gray(` (${dep.version.substring(0, 30)})`) : '';
+    const usedBy = chalk.gray(` - ${dep.usedBy.join(', ')}`);
+    console.log(`  ${icon} ${dep.name}${version}${usedBy}`);
+    if (dep.status !== 'ok') {
+      console.log(chalk.gray(`    → ${dep.installHint}`));
+    }
+  }
+
+  // Python packages
+  if (globalResults.python.length > 0) {
+    console.log(chalk.cyan('\nPython Packages:'));
+    for (const pkg of globalResults.python) {
+      const icon = pkg.status === 'ok' ? chalk.green('✓') : chalk.yellow('○');
+      const usedBy = chalk.gray(` - ${pkg.usedBy.join(', ')}`);
+      console.log(`  ${icon} ${pkg.name}${usedBy}`);
+      if (!pkg.installed) {
+        console.log(chalk.gray(`    → ${pkg.installCmd}`));
+      }
+    }
+  }
+
+  // Optional
+  console.log(chalk.cyan('\nOptional:'));
+  for (const dep of globalResults.optional) {
+    const icon = dep.status === 'ok' ? chalk.green('✓') : chalk.gray('○');
+    const version = dep.version ? chalk.gray(` (${dep.version.substring(0, 30)})`) : '';
+    const usedBy = chalk.gray(` - ${dep.usedBy.join(', ')}`);
+    console.log(`  ${icon} ${dep.name}${version}${usedBy}`);
+    if (dep.status !== 'ok') {
+      console.log(chalk.gray(`    → ${dep.installHint}`));
+    }
+  }
+
+  // Project deps
+  if (projectResults) {
+    console.log('\n' + chalk.bold('Project Dependencies:'));
+    console.log('─'.repeat(50));
+
+    if (projectResults.noPackageJson) {
+      console.log(chalk.gray('  No package.json found (not a Node.js project)'));
+    } else {
+      for (const dep of projectResults.npm) {
+        const icon = dep.status === 'ok' ? chalk.green('✓') : chalk.yellow('○');
+        const usedBy = chalk.gray(` - ${dep.usedBy.join(', ')}`);
+        console.log(`  ${icon} ${dep.name}${usedBy}`);
+      }
+
+      if (projectResults.missing.length > 0) {
+        console.log(chalk.yellow('\n  To install missing dependencies:'));
+        const names = projectResults.missing.map(d => d.name).join(' ');
+        console.log(chalk.cyan(`    npm install -D ${names}`));
+      }
+    }
+  }
+
+  console.log('');
+}
+
+/**
+ * Install missing project dependencies
+ */
+export async function installProjectDeps(projectPath, deps, options = {}) {
+  const npmDeps = deps.filter(d => !d.global);
+
+  if (npmDeps.length > 0) {
+    console.log(chalk.cyan('Installing npm dependencies...'));
+    const names = npmDeps.map(d => d.name).join(' ');
+    try {
+      execSync(`npm install -D ${names}`, {
+        cwd: projectPath,
+        stdio: 'inherit'
+      });
+      return true;
+    } catch (e) {
+      console.log(chalk.red('Failed to install npm dependencies'));
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Install missing Python packages
+ */
+export async function installPythonDeps(packages) {
+  if (packages.length === 0) return true;
+
+  console.log(chalk.cyan('Installing Python packages...'));
+
+  for (const pkg of packages) {
+    try {
+      console.log(`  Installing ${pkg.name}...`);
+      execSync(pkg.installCmd, { stdio: 'inherit' });
+    } catch (e) {
+      console.log(chalk.red(`  Failed to install ${pkg.name}`));
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Get summary of what's missing
+ */
+export function getMissingSummary(globalResults, projectResults) {
+  const missing = {
+    critical: [],
+    recommended: [],
+    optional: []
+  };
+
+  for (const dep of globalResults.required) {
+    if (dep.status !== 'ok') {
+      missing.critical.push({
+        name: dep.name,
+        hint: dep.installHint
+      });
+    }
+  }
+
+  for (const dep of globalResults.recommended) {
+    if (dep.status !== 'ok') {
+      missing.recommended.push({
+        name: dep.name,
+        hint: dep.installHint
+      });
+    }
+  }
+
+  for (const pkg of globalResults.python || []) {
+    if (!pkg.installed) {
+      missing.recommended.push({
+        name: pkg.name,
+        hint: pkg.installCmd
+      });
+    }
+  }
+
+  if (projectResults && projectResults.missing) {
+    for (const dep of projectResults.missing) {
+      missing.optional.push({
+        name: dep.name,
+        hint: `npm install -D ${dep.name}`
+      });
+    }
+  }
+
+  return missing;
+}