@cloudstreamsoftware/claude-tools 1.0.0 → 1.2.0

package/scripts/verifiers/hooks.js

@@ -0,0 +1,188 @@
+/**
+ * Hooks Verifier - Hook configuration and script validation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { createCheck, createResult, SEVERITY } = require('../lib/verify-formatter');
+const { getClaudeDir } = require('../lib/utils');
+const { getPluginRoot } = require('./plugin');
+
+const NAME = 'Hooks';
+
+/**
+ * Check hooks.json exists and is valid
+ */
+function checkHooksJson() {
+  const pluginRoot = getPluginRoot();
+  const hooksPath = path.join(pluginRoot, 'hooks', 'hooks.json');
+
+  if (!fs.existsSync(hooksPath)) {
+    return createCheck('hooks.json exists', false, {
+      severity: SEVERITY.WARNING,
+      message: 'not found',
+      remediation: 'Create hooks/hooks.json with hook definitions',
+    });
+  }
+
+  try {
+    const content = fs.readFileSync(hooksPath, 'utf8');
+    const config = JSON.parse(content);
+
+    // Count total hooks across all events
+    let hookCount = 0;
+    if (config.hooks && typeof config.hooks === 'object') {
+      for (const event of Object.keys(config.hooks)) {
+        const eventHooks = config.hooks[event];
+        if (Array.isArray(eventHooks)) {
+          hookCount += eventHooks.length;
+        }
+      }
+    }
+
+    const eventCount = config.hooks ? Object.keys(config.hooks).length : 0;
+
+    return createCheck('hooks.json valid', true, {
+      message: `${eventCount} events, ${hookCount} hooks`,
+    });
+  } catch (err) {
+    return createCheck('hooks.json valid', false, {
+      severity: SEVERITY.CRITICAL,
+      message: 'JSON parse error',
+      remediation: 'Fix JSON syntax in hooks/hooks.json',
+    });
+  }
+}
+
+/**
+ * Check global settings.json has hooks configured
+ */
+function checkSettingsHooks() {
+  const settingsPath = path.join(getClaudeDir(), 'settings.json');
+
+  if (!fs.existsSync(settingsPath)) {
+    return createCheck('settings.json hooks', false, {
+      severity: SEVERITY.WARNING,
+      message: 'settings.json not found',
+      remediation: 'Create ~/.claude/settings.json with hooks configuration',
+    });
+  }
+
+  try {
+    const content = fs.readFileSync(settingsPath, 'utf8');
+    const settings = JSON.parse(content);
+
+    if (!settings.hooks || Object.keys(settings.hooks).length === 0) {
+      return createCheck('settings.json hooks', false, {
+        severity: SEVERITY.WARNING,
+        message: 'no hooks configured',
+        remediation: 'Add hooks section to ~/.claude/settings.json',
+      });
+    }
+
+    const eventCount = Object.keys(settings.hooks).length;
+    return createCheck('settings.json hooks', true, {
+      message: `${eventCount} events configured`,
+    });
+  } catch (err) {
+    return createCheck('settings.json hooks', false, {
+      severity: SEVERITY.WARNING,
+      message: 'cannot parse settings.json',
+      remediation: 'Fix JSON syntax in ~/.claude/settings.json',
+    });
+  }
+}
+
+/**
+ * Check hook scripts exist
+ */
+function checkHookScripts() {
+  const pluginRoot = getPluginRoot();
+  const scriptsDir = path.join(pluginRoot, 'scripts', 'hooks');
+  const checks = [];
+
+  // Key hook scripts to verify
+  const keyScripts = [
+    'prompt-router.js',
+    'session-start.js',
+    'credential-check.js',
+    'skill-injector.js',
+    'quality-gate-enforcer.js',
+  ];
+
+  for (const script of keyScripts) {
+    const scriptPath = path.join(scriptsDir, script);
+    const exists = fs.existsSync(scriptPath);
+
+    checks.push(
+      createCheck(script, exists, {
+        severity: exists ? SEVERITY.INFO : SEVERITY.WARNING,
+        message: exists ? 'found' : 'missing',
+        remediation: exists ? null : `Create ${script} in scripts/hooks/`,
+      })
+    );
+  }
+
+  return checks;
+}
+
+/**
+ * Check hook scripts are syntactically valid
+ */
+function checkHookScriptsSyntax() {
+  const pluginRoot = getPluginRoot();
+  const scriptsDir = path.join(pluginRoot, 'scripts', 'hooks');
+  const checks = [];
+
+  if (!fs.existsSync(scriptsDir)) {
+    return [
+      createCheck('hook scripts syntax', false, {
+        severity: SEVERITY.WARNING,
+        message: 'scripts/hooks/ not found',
+      }),
+    ];
+  }
+
+  const scripts = fs.readdirSync(scriptsDir).filter((f) => f.endsWith('.js'));
+
+  for (const script of scripts.slice(0, 5)) {
+    // Check first 5 scripts
+    const scriptPath = path.join(scriptsDir, script);
+    try {
+      // Use Node's syntax check
+      execSync(`node --check "${scriptPath}"`, { encoding: 'utf8', stdio: 'pipe' });
+      checks.push(
+        createCheck(`${script} syntax`, true, {
+          message: 'valid',
+        })
+      );
+    } catch (err) {
+      checks.push(
+        createCheck(`${script} syntax`, false, {
+          severity: SEVERITY.CRITICAL,
+          message: 'syntax error',
+          remediation: `Fix syntax error in scripts/hooks/${script}`,
+        })
+      );
+    }
+  }
+
+  return checks;
+}
+
+/**
+ * Run all hooks checks
+ */
+function verify() {
+  const checks = [
+    checkHooksJson(),
+    checkSettingsHooks(),
+    ...checkHookScripts(),
+    ...checkHookScriptsSyntax(),
+  ];
+
+  return createResult(NAME, checks);
+}
+
+module.exports = { verify, NAME };

package/scripts/verifiers/index.js

@@ -0,0 +1,38 @@
+/**
+ * Verifiers Index - Registry and factories for verification modules
+ */
+
+const { createCheck, createResult, SEVERITY } = require('../lib/verify-formatter');
+
+// Export factories for use by verifier modules
+module.exports = {
+  createCheck,
+  createResult,
+  SEVERITY,
+
+  // Verifier modules (lazy loaded to avoid circular deps)
+  get environment() {
+    return require('./environment');
+  },
+  get persistence() {
+    return require('./persistence');
+  },
+  get plugin() {
+    return require('./plugin');
+  },
+  get config() {
+    return require('./config');
+  },
+  get hooks() {
+    return require('./hooks');
+  },
+  get skills() {
+    return require('./skills');
+  },
+  get agents() {
+    return require('./agents');
+  },
+
+  // Execution order (dependency-based)
+  executionOrder: ['environment', 'persistence', 'plugin', 'config', 'hooks', 'skills', 'agents'],
+};

package/scripts/verifiers/persistence.js

@@ -0,0 +1,140 @@
+/**
+ * Persistence Verifier - ~/.claude directory checks
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { createCheck, createResult, SEVERITY } = require('../lib/verify-formatter');
+const { getClaudeDir, ensureDir } = require('../lib/utils');
+
+const NAME = 'Persistence';
+
+/**
+ * Check ~/.claude exists
+ */
+function checkClaudeDir() {
+  const claudeDir = getClaudeDir();
+  const exists = fs.existsSync(claudeDir);
+
+  return createCheck('~/.claude exists', exists, {
+    severity: exists ? SEVERITY.INFO : SEVERITY.CRITICAL,
+    remediation: `Create directory: mkdir "${claudeDir}"`,
+  });
+}
+
+/**
+ * Check ~/.claude is writable
+ */
+function checkClaudeDirWritable() {
+  const claudeDir = getClaudeDir();
+
+  if (!fs.existsSync(claudeDir)) {
+    return createCheck('~/.claude writable', false, {
+      severity: SEVERITY.CRITICAL,
+      message: 'directory missing',
+      remediation: `Create directory: mkdir "${claudeDir}"`,
+    });
+  }
+
+  try {
+    const testFile = path.join(claudeDir, '.verify-test');
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+    return createCheck('~/.claude writable', true);
+  } catch (err) {
+    return createCheck('~/.claude writable', false, {
+      severity: SEVERITY.CRITICAL,
+      message: err.code,
+      remediation: 'Fix permissions on ~/.claude directory',
+    });
+  }
+}
+
+/**
+ * Check sessions directory
+ */
+function checkSessionsDir() {
+  const sessionsDir = path.join(getClaudeDir(), 'sessions');
+
+  if (fs.existsSync(sessionsDir)) {
+    return createCheck('sessions/ exists', true);
+  }
+
+  // Try to create it
+  try {
+    ensureDir(sessionsDir);
+    return createCheck('sessions/ exists', true, {
+      message: 'created',
+    });
+  } catch {
+    return createCheck('sessions/ exists', false, {
+      severity: SEVERITY.WARNING,
+      remediation: `Create directory: mkdir "${sessionsDir}"`,
+    });
+  }
+}
+
+/**
+ * Check memory directory
+ */
+function checkMemoryDir() {
+  const memoryDir = path.join(getClaudeDir(), 'memory');
+
+  if (fs.existsSync(memoryDir)) {
+    return createCheck('memory/ exists', true);
+  }
+
+  // Try to create it
+  try {
+    ensureDir(memoryDir);
+    return createCheck('memory/ exists', true, {
+      message: 'created',
+    });
+  } catch {
+    return createCheck('memory/ exists', false, {
+      severity: SEVERITY.WARNING,
+      remediation: `Create directory: mkdir "${memoryDir}"`,
+    });
+  }
+}
+
+/**
+ * Check plans directory
+ */
+function checkPlansDir() {
+  const plansDir = path.join(getClaudeDir(), 'plans');
+
+  if (fs.existsSync(plansDir)) {
+    return createCheck('plans/ exists', true);
+  }
+
+  // Try to create it
+  try {
+    ensureDir(plansDir);
+    return createCheck('plans/ exists', true, {
+      message: 'created',
+    });
+  } catch {
+    return createCheck('plans/ exists', false, {
+      severity: SEVERITY.WARNING,
+      remediation: `Create directory: mkdir "${plansDir}"`,
+    });
+  }
+}
+
+/**
+ * Run all persistence checks
+ */
+function verify() {
+  const checks = [
+    checkClaudeDir(),
+    checkClaudeDirWritable(),
+    checkSessionsDir(),
+    checkMemoryDir(),
+    checkPlansDir(),
+  ];
+
+  return createResult(NAME, checks);
+}
+
+module.exports = { verify, NAME };

package/scripts/verifiers/plugin.js

@@ -0,0 +1,215 @@
+/**
+ * Plugin Verifier - plugin.json and directory structure validation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { createCheck, createResult, SEVERITY } = require('../lib/verify-formatter');
+
+const NAME = 'Plugin';
+
+/**
+ * Get plugin root directory (where assets like commands/, skills/, hooks/ live)
+ * Note: plugin.json is in .claude-plugin/ but paths are relative to parent (repo root)
+ */
+function getPluginRoot() {
+  // Check multiple possible locations for plugin.json
+  const possiblePluginJsonLocations = [
+    path.join(process.cwd(), '.claude-plugin', 'plugin.json'),
+    path.join(process.cwd(), 'plugin.json'),
+    path.join(__dirname, '..', '..', '.claude-plugin', 'plugin.json'),
+    path.join(__dirname, '..', '..', 'plugin.json'),
+  ];
+
+  for (const pluginPath of possiblePluginJsonLocations) {
+    if (fs.existsSync(pluginPath)) {
+      // Return the repo root (parent of .claude-plugin)
+      // because that's where commands/, skills/, hooks/ actually live
+      const pluginDir = path.dirname(pluginPath);
+      if (pluginDir.endsWith('.claude-plugin')) {
+        return path.dirname(pluginDir); // Return parent of .claude-plugin
+      }
+      return pluginDir;
+    }
+  }
+
+  return path.join(__dirname, '..', '..');
+}
+
+/**
+ * Get path to plugin.json file
+ */
+function getPluginJsonPath() {
+  const root = getPluginRoot();
+  const locations = [
+    path.join(root, '.claude-plugin', 'plugin.json'),
+    path.join(root, 'plugin.json'),
+  ];
+
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      return loc;
+    }
+  }
+
+  return path.join(root, '.claude-plugin', 'plugin.json');
+}
+
+/**
+ * Check plugin.json exists and is valid
+ */
+function checkPluginJson() {
+  const pluginPath = getPluginJsonPath();
+
+  if (!fs.existsSync(pluginPath)) {
+    return createCheck('plugin.json exists', false, {
+      severity: SEVERITY.CRITICAL,
+      remediation: 'Re-clone the repository or check plugin.json location',
+    });
+  }
+
+  try {
+    const content = fs.readFileSync(pluginPath, 'utf8');
+    const plugin = JSON.parse(content);
+
+    if (!plugin.name) {
+      return createCheck('plugin.json valid', false, {
+        severity: SEVERITY.CRITICAL,
+        message: 'missing name field',
+        remediation: 'Add "name" field to plugin.json',
+      });
+    }
+
+    return createCheck('plugin.json valid', true, {
+      message: plugin.name,
+    });
+  } catch (err) {
+    return createCheck('plugin.json valid', false, {
+      severity: SEVERITY.CRITICAL,
+      message: 'JSON parse error',
+      remediation: 'Fix JSON syntax in plugin.json',
+    });
+  }
+}
+
+/**
+ * Check plugin has required paths configured
+ */
+function checkPluginPaths() {
+  const pluginRoot = getPluginRoot();
+  const pluginPath = getPluginJsonPath();
+
+  try {
+    const plugin = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
+    const checks = [];
+
+    // Check commands path
+    if (plugin.commands) {
+      const commandsDir = path.join(pluginRoot, plugin.commands);
+      const exists = fs.existsSync(commandsDir);
+      const count = exists
+        ? fs.readdirSync(commandsDir).filter((f) => f.endsWith('.md')).length
+        : 0;
+      checks.push(
+        createCheck('commands/', exists, {
+          message: exists ? `${count} files` : 'missing',
+          severity: exists ? SEVERITY.INFO : SEVERITY.CRITICAL,
+          remediation: 'Re-clone repository or check commands path in plugin.json',
+        })
+      );
+    } else {
+      checks.push(
+        createCheck('commands/ configured', false, {
+          severity: SEVERITY.CRITICAL,
+          remediation: 'Add "commands" path to plugin.json',
+        })
+      );
+    }
+
+    // Check skills path
+    if (plugin.skills) {
+      const skillsDir = path.join(pluginRoot, plugin.skills);
+      const exists = fs.existsSync(skillsDir);
+      const count = exists
+        ? fs
+            .readdirSync(skillsDir)
+            .filter((f) => fs.statSync(path.join(skillsDir, f)).isDirectory()).length
+        : 0;
+      checks.push(
+        createCheck('skills/', exists, {
+          message: exists ? `${count} dirs` : 'missing',
+          severity: exists ? SEVERITY.INFO : SEVERITY.CRITICAL,
+          remediation: 'Re-clone repository or check skills path in plugin.json',
+        })
+      );
+    } else {
+      checks.push(
+        createCheck('skills/ configured', false, {
+          severity: SEVERITY.CRITICAL,
+          remediation: 'Add "skills" path to plugin.json',
+        })
+      );
+    }
+
+    // Check hooks path
+    if (plugin.hooks) {
+      const hooksDir = path.join(pluginRoot, plugin.hooks);
+      const exists = fs.existsSync(hooksDir);
+      checks.push(
+        createCheck('hooks/', exists, {
+          message: exists ? 'found' : 'missing',
+          severity: exists ? SEVERITY.INFO : SEVERITY.CRITICAL,
+          remediation: 'Re-clone repository or check hooks path in plugin.json',
+        })
+      );
+    } else {
+      checks.push(
+        createCheck('hooks/ configured', false, {
+          severity: SEVERITY.WARNING,
+          remediation: 'Add "hooks" path to plugin.json',
+        })
+      );
+    }
+
+    return checks;
+  } catch {
+    return [
+      createCheck('plugin paths', false, {
+        severity: SEVERITY.CRITICAL,
+        message: 'cannot read plugin.json',
+      }),
+    ];
+  }
+}
+
+/**
+ * Check agents directory (optional but recommended)
+ */
+function checkAgentsDir() {
+  const pluginRoot = getPluginRoot();
+  const agentsDir = path.join(pluginRoot, 'agents');
+
+  if (fs.existsSync(agentsDir)) {
+    const count = fs.readdirSync(agentsDir).filter((f) => f.endsWith('.md')).length;
+    return createCheck('agents/', true, {
+      message: `${count} files`,
+    });
+  }
+
+  return createCheck('agents/', false, {
+    severity: SEVERITY.WARNING,
+    message: 'not found',
+    remediation: 'Create agents/ directory for agent definitions',
+  });
+}
+
+/**
+ * Run all plugin checks
+ */
+function verify() {
+  const checks = [checkPluginJson(), ...checkPluginPaths(), checkAgentsDir()];
+
+  return createResult(NAME, checks);
+}
+
+module.exports = { verify, NAME, getPluginRoot, getPluginJsonPath };