aiox-core 5.0.0

package/.aiox-core/core/health-check/checks/services/claude-code.js

@@ -0,0 +1,137 @@
+/**
+ * Claude Code Check
+ *
+ * Verifies Claude Code CLI installation and configuration.
+ *
+ * @module aiox-core/health-check/checks/services/claude-code
+ * @version 1.0.0
+ * @story HCS-2 - Health Check System Implementation
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const { BaseCheck, CheckSeverity, CheckDomain } = require('../../base-check');
+
+/**
+ * Claude Code check
+ *
+ * @class ClaudeCodeCheck
+ * @extends BaseCheck
+ */
+class ClaudeCodeCheck extends BaseCheck {
+  constructor() {
+    super({
+      id: 'services.claude-code',
+      name: 'Claude Code',
+      description: 'Verifies Claude Code CLI configuration',
+      domain: CheckDomain.SERVICES,
+      severity: CheckSeverity.LOW,
+      timeout: 3000,
+      cacheable: true,
+      healingTier: 0,
+      tags: ['claude', 'ai', 'cli'],
+    });
+  }
+
+  /**
+   * Execute the check
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Check result
+   */
+  async execute(context) {
+    const projectRoot = context.projectRoot || process.cwd();
+    const homeDir = os.homedir();
+
+    const details = {
+      installed: false,
+      version: null,
+      projectConfig: false,
+      globalConfig: false,
+    };
+
+    // Check if claude is installed
+    try {
+      const version = execSync('claude --version', {
+        encoding: 'utf8',
+        timeout: 5000,
+        windowsHide: true,
+      }).trim();
+
+      details.installed = true;
+      details.version = version;
+    } catch {
+      // Not installed - check config anyway
+    }
+
+    // Check project .claude directory
+    try {
+      const claudeDir = path.join(projectRoot, '.claude');
+      await fs.access(claudeDir);
+      details.projectConfig = true;
+
+      // Check for CLAUDE.md
+      try {
+        await fs.access(path.join(claudeDir, 'CLAUDE.md'));
+        details.hasProjectInstructions = true;
+      } catch {
+        details.hasProjectInstructions = false;
+      }
+    } catch {
+      // No project config
+    }
+
+    // Check global config
+    try {
+      const globalConfig = path.join(homeDir, '.claude.json');
+      await fs.access(globalConfig);
+      details.globalConfig = true;
+    } catch {
+      // No global config
+    }
+
+    // Check for global CLAUDE.md
+    try {
+      const globalClaudeMd = path.join(homeDir, '.claude', 'CLAUDE.md');
+      await fs.access(globalClaudeMd);
+      details.hasGlobalInstructions = true;
+    } catch {
+      details.hasGlobalInstructions = false;
+    }
+
+    if (!details.installed && !details.projectConfig && !details.globalConfig) {
+      return this.pass('Claude Code not detected (not using Claude Code)', {
+        details,
+      });
+    }
+
+    const issues = [];
+
+    if (!details.projectConfig) {
+      issues.push('No project-level .claude directory');
+    }
+
+    if (details.projectConfig && !details.hasProjectInstructions) {
+      issues.push('Project .claude/CLAUDE.md not found');
+    }
+
+    if (issues.length > 0) {
+      return this.warning(`Claude Code configuration incomplete: ${issues.join(', ')}`, {
+        recommendation: 'Add .claude/CLAUDE.md for project-specific instructions',
+        details: { ...details, issues },
+      });
+    }
+
+    const parts = [];
+    if (details.installed) parts.push(`CLI v${details.version}`);
+    if (details.projectConfig) parts.push('project config');
+    if (details.globalConfig) parts.push('global config');
+
+    return this.pass(`Claude Code configured (${parts.join(', ')})`, {
+      details,
+    });
+  }
+}
+
+module.exports = ClaudeCodeCheck;

package/.aiox-core/core/health-check/checks/services/gemini-cli.js

@@ -0,0 +1,239 @@
+/**
+ * Gemini CLI Check
+ *
+ * Verifies Gemini CLI installation, authentication, and configuration.
+ * Detects available features including Preview features, Extensions, and Hooks.
+ *
+ * @module aiox-core/health-check/checks/services/gemini-cli
+ * @version 1.0.0
+ * @story GEMINI-INT Story 1 - Gemini CLI Health Check & Detection
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const { BaseCheck, CheckSeverity, CheckDomain } = require('../../base-check');
+
+/**
+ * Gemini CLI check
+ *
+ * @class GeminiCliCheck
+ * @extends BaseCheck
+ */
+class GeminiCliCheck extends BaseCheck {
+  constructor() {
+    super({
+      id: 'services.gemini-cli',
+      name: 'Gemini CLI',
+      description: 'Verifies Gemini CLI installation and configuration',
+      domain: CheckDomain.SERVICES,
+      severity: CheckSeverity.LOW,
+      timeout: 5000,
+      cacheable: true,
+      healingTier: 0,
+      tags: ['gemini', 'google', 'ai', 'cli'],
+    });
+  }
+
+  /**
+   * Execute the check
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Check result
+   */
+  async execute(context) {
+    const projectRoot = context.projectRoot || process.cwd();
+    const homeDir = os.homedir();
+
+    const details = {
+      installed: false,
+      version: null,
+      authenticated: false,
+      projectConfig: false,
+      globalConfig: false,
+      features: {
+        previewFeatures: false,
+        hooks: false,
+        extensions: [],
+      },
+    };
+
+    // Check if gemini is installed
+    try {
+      const version = execSync('gemini --version', {
+        encoding: 'utf8',
+        timeout: 5000,
+        windowsHide: true,
+      }).trim();
+
+      details.installed = true;
+      details.version = version;
+    } catch {
+      // Not installed
+    }
+
+    // Check authentication status
+    if (details.installed) {
+      try {
+        const authStatus = execSync('gemini auth status 2>&1', {
+          encoding: 'utf8',
+          timeout: 5000,
+          windowsHide: true,
+        });
+        details.authenticated = !authStatus.toLowerCase().includes('not authenticated');
+      } catch {
+        details.authenticated = false;
+      }
+    }
+
+    // Check project .gemini directory
+    try {
+      const geminiDir = path.join(projectRoot, '.gemini');
+      await fs.access(geminiDir);
+      details.projectConfig = true;
+
+      // Check for rules.md (AIOX rules)
+      try {
+        await fs.access(path.join(geminiDir, 'rules.md'));
+        details.hasProjectRules = true;
+      } catch {
+        details.hasProjectRules = false;
+      }
+
+      // Check for settings.json (hooks, extensions config)
+      try {
+        const settingsPath = path.join(geminiDir, 'settings.json');
+        const settingsContent = await fs.readFile(settingsPath, 'utf8');
+        const settings = JSON.parse(settingsContent);
+
+        // Check for hooks configuration
+        if (settings.hooks && Object.keys(settings.hooks).length > 0) {
+          details.features.hooks = true;
+          details.features.hookEvents = Object.keys(settings.hooks);
+        }
+
+        // Check for preview features
+        if (settings.previewFeatures === true) {
+          details.features.previewFeatures = true;
+        }
+      } catch {
+        // No settings.json or invalid JSON
+      }
+
+      // Check for AIOX agents
+      try {
+        const agentsDir = path.join(geminiDir, 'rules', 'AIOX', 'agents');
+        const agentFiles = await fs.readdir(agentsDir);
+        details.aioxAgents = agentFiles.filter((f) => f.endsWith('.md')).length;
+      } catch {
+        details.aioxAgents = 0;
+      }
+    } catch {
+      // No project config
+    }
+
+    // Check global config (~/.gemini or similar)
+    try {
+      const globalGeminiDir = path.join(homeDir, '.gemini');
+      await fs.access(globalGeminiDir);
+      details.globalConfig = true;
+
+      // Check global settings
+      try {
+        const globalSettingsPath = path.join(globalGeminiDir, 'settings.json');
+        const globalSettings = JSON.parse(await fs.readFile(globalSettingsPath, 'utf8'));
+
+        if (globalSettings.previewFeatures === true) {
+          details.features.previewFeatures = true;
+        }
+      } catch {
+        // No global settings
+      }
+    } catch {
+      // No global config
+    }
+
+    // Check for installed extensions
+    if (details.installed) {
+      try {
+        const extensionsList = execSync('gemini extensions list --output-format json 2>/dev/null', {
+          encoding: 'utf8',
+          timeout: 10000,
+          windowsHide: true,
+        });
+        const extensions = JSON.parse(extensionsList);
+        if (Array.isArray(extensions)) {
+          details.features.extensions = extensions.map((e) => e.name || e);
+        }
+      } catch {
+        // Extensions command not available or failed
+      }
+    }
+
+    // Not using Gemini CLI
+    if (!details.installed && !details.projectConfig && !details.globalConfig) {
+      return this.pass('Gemini CLI not detected (not using Gemini CLI)', {
+        details,
+      });
+    }
+
+    const issues = [];
+    const warnings = [];
+
+    // Check for issues
+    if (details.installed && !details.authenticated) {
+      issues.push('Not authenticated');
+    }
+
+    if (!details.projectConfig) {
+      warnings.push('No project-level .gemini directory');
+    }
+
+    if (details.projectConfig && !details.hasProjectRules) {
+      warnings.push('Project .gemini/rules.md not found');
+    }
+
+    if (details.projectConfig && details.aioxAgents === 0) {
+      warnings.push('No AIOX agents installed for Gemini CLI');
+    }
+
+    if (!details.features.previewFeatures) {
+      warnings.push('Preview features not enabled (needed for Gemini 3)');
+    }
+
+    // Return result based on severity
+    if (issues.length > 0) {
+      return this.warning(`Gemini CLI needs attention: ${issues.join(', ')}`, {
+        recommendation: issues.includes('Not authenticated')
+          ? 'Run `gemini` to authenticate with your Google account'
+          : 'Run `npx aiox-core install` and select Gemini CLI',
+        details: { ...details, issues, warnings },
+      });
+    }
+
+    if (warnings.length > 0) {
+      return this.warning(`Gemini CLI configuration incomplete: ${warnings.join(', ')}`, {
+        recommendation: 'Run `npx aiox-core install` and select Gemini CLI',
+        details: { ...details, warnings },
+      });
+    }
+
+    // Build success message
+    const parts = [];
+    if (details.installed) parts.push(`CLI v${details.version}`);
+    if (details.authenticated) parts.push('authenticated');
+    if (details.projectConfig) parts.push('project config');
+    if (details.features.previewFeatures) parts.push('preview features');
+    if (details.features.hooks) parts.push(`${details.features.hookEvents.length} hooks`);
+    if (details.features.extensions.length > 0) {
+      parts.push(`${details.features.extensions.length} extensions`);
+    }
+    if (details.aioxAgents > 0) parts.push(`${details.aioxAgents} AIOX agents`);
+
+    return this.pass(`Gemini CLI configured (${parts.join(', ')})`, {
+      details,
+    });
+  }
+}
+
+module.exports = GeminiCliCheck;

package/.aiox-core/core/health-check/checks/services/github-cli.js

@@ -0,0 +1,115 @@
+/**
+ * GitHub CLI Check
+ *
+ * Verifies GitHub CLI (gh) integration.
+ *
+ * @module aiox-core/health-check/checks/services/github-cli
+ * @version 1.0.0
+ * @story HCS-2 - Health Check System Implementation
+ */
+
+const { execSync } = require('child_process');
+const { BaseCheck, CheckSeverity, CheckDomain } = require('../../base-check');
+
+/**
+ * GitHub CLI check
+ *
+ * @class GithubCliCheck
+ * @extends BaseCheck
+ */
+class GithubCliCheck extends BaseCheck {
+  constructor() {
+    super({
+      id: 'services.github-cli',
+      name: 'GitHub CLI',
+      description: 'Verifies GitHub CLI (gh) installation and authentication',
+      domain: CheckDomain.SERVICES,
+      severity: CheckSeverity.MEDIUM,
+      timeout: 5000,
+      cacheable: true,
+      healingTier: 3, // Manual installation
+      tags: ['github', 'cli', 'integration'],
+    });
+  }
+
+  /**
+   * Execute the check
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Check result
+   */
+  async execute(_context) {
+    const details = {
+      installed: false,
+      version: null,
+      authenticated: false,
+      user: null,
+    };
+
+    // Check if gh is installed
+    try {
+      const version = execSync('gh --version', {
+        encoding: 'utf8',
+        timeout: 5000,
+        windowsHide: true,
+      }).trim();
+
+      const versionMatch = version.match(/(\d+\.\d+\.\d+)/);
+      details.installed = true;
+      details.version = versionMatch ? versionMatch[1] : 'unknown';
+    } catch {
+      return this.pass('GitHub CLI (gh) not installed (optional)', {
+        details,
+      });
+    }
+
+    // Check authentication status
+    try {
+      const authStatus = execSync('gh auth status', {
+        encoding: 'utf8',
+        timeout: 10000,
+        windowsHide: true,
+      });
+
+      details.authenticated = true;
+
+      // Try to get username
+      const userMatch = authStatus.match(/Logged in to .+ as (\w+)/);
+      if (userMatch) {
+        details.user = userMatch[1];
+      }
+    } catch (_error) {
+      // Not authenticated
+      details.authenticated = false;
+
+      return this.warning(`GitHub CLI installed (v${details.version}) but not authenticated`, {
+        recommendation: 'Run: gh auth login',
+        details,
+      });
+    }
+
+    return this.pass(`GitHub CLI v${details.version} authenticated as ${details.user || 'user'}`, {
+      details,
+    });
+  }
+
+  /**
+   * Get healer (manual guide)
+   */
+  getHealer() {
+    return {
+      name: 'github-cli-setup',
+      action: 'manual',
+      manualGuide: 'Set up GitHub CLI',
+      steps: [
+        'Install gh: https://cli.github.com/',
+        'Run: gh auth login',
+        'Select GitHub.com or Enterprise',
+        'Choose authentication method (browser recommended)',
+        'Verify with: gh auth status',
+      ],
+      documentation: 'https://cli.github.com/manual/',
+    };
+  }
+}
+
+module.exports = GithubCliCheck;

package/.aiox-core/core/health-check/checks/services/index.js

@@ -0,0 +1,27 @@
+/**
+ * Service Integration Domain Checks
+ *
+ * Checks for external service integrations.
+ * Domain: services
+ *
+ * @module aiox-core/health-check/checks/services
+ * @version 1.0.0
+ * @story HCS-2 - Health Check System Implementation
+ */
+
+const McpIntegrationCheck = require('./mcp-integration');
+const GithubCliCheck = require('./github-cli');
+const ClaudeCodeCheck = require('./claude-code');
+const GeminiCliCheck = require('./gemini-cli');
+const ApiEndpointsCheck = require('./api-endpoints');
+
+/**
+ * All services domain checks
+ */
+module.exports = {
+  McpIntegrationCheck,
+  GithubCliCheck,
+  ClaudeCodeCheck,
+  GeminiCliCheck,
+  ApiEndpointsCheck,
+};

package/.aiox-core/core/health-check/checks/services/mcp-integration.js

@@ -0,0 +1,123 @@
+/**
+ * MCP Integration Check
+ *
+ * Verifies MCP (Model Context Protocol) server integration.
+ *
+ * @module aiox-core/health-check/checks/services/mcp-integration
+ * @version 1.0.0
+ * @story HCS-2 - Health Check System Implementation
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { BaseCheck, CheckSeverity, CheckDomain } = require('../../base-check');
+
+/**
+ * MCP integration check
+ *
+ * @class McpIntegrationCheck
+ * @extends BaseCheck
+ */
+class McpIntegrationCheck extends BaseCheck {
+  constructor() {
+    super({
+      id: 'services.mcp-integration',
+      name: 'MCP Integration',
+      description: 'Verifies MCP server configuration',
+      domain: CheckDomain.SERVICES,
+      severity: CheckSeverity.MEDIUM,
+      timeout: 3000,
+      cacheable: true,
+      healingTier: 0,
+      tags: ['mcp', 'integration', 'ai'],
+    });
+  }
+
+  /**
+   * Execute the check
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Check result
+   */
+  async execute(context) {
+    const projectRoot = context.projectRoot || process.cwd();
+    const homeDir = os.homedir();
+
+    const mcpConfigs = {
+      found: [],
+      servers: [],
+      issues: [],
+    };
+
+    // Check .mcp.json in project
+    try {
+      const projectMcp = path.join(projectRoot, '.mcp.json');
+      const content = await fs.readFile(projectMcp, 'utf8');
+      const config = JSON.parse(content);
+
+      mcpConfigs.found.push('.mcp.json (project)');
+
+      if (config.mcpServers) {
+        const servers = Object.keys(config.mcpServers);
+        mcpConfigs.servers.push(...servers.map((s) => `${s} (project)`));
+      }
+    } catch {
+      // Not found or invalid
+    }
+
+    // Check global Claude config
+    try {
+      const globalConfig = path.join(homeDir, '.claude.json');
+      const content = await fs.readFile(globalConfig, 'utf8');
+      const config = JSON.parse(content);
+
+      if (config.mcpServers) {
+        mcpConfigs.found.push('.claude.json (global)');
+        const servers = Object.keys(config.mcpServers);
+        mcpConfigs.servers.push(...servers.map((s) => `${s} (global)`));
+      }
+    } catch {
+      // Not found or invalid
+    }
+
+    // Check .claude/settings.json
+    try {
+      const localConfig = path.join(projectRoot, '.claude', 'settings.json');
+      const content = await fs.readFile(localConfig, 'utf8');
+      const config = JSON.parse(content);
+
+      if (config.mcpServers) {
+        mcpConfigs.found.push('.claude/settings.json');
+        const servers = Object.keys(config.mcpServers);
+        mcpConfigs.servers.push(...servers.map((s) => `${s} (local)`));
+      }
+    } catch {
+      // Not found or invalid
+    }
+
+    const details = {
+      configs: mcpConfigs.found,
+      servers: mcpConfigs.servers,
+      serverCount: mcpConfigs.servers.length,
+    };
+
+    if (mcpConfigs.found.length === 0) {
+      return this.pass('No MCP configuration found (not using MCP)', {
+        details,
+      });
+    }
+
+    if (mcpConfigs.servers.length === 0) {
+      return this.warning('MCP config found but no servers defined', {
+        recommendation: 'Add MCP servers to your configuration',
+        details,
+      });
+    }
+
+    return this.pass(`MCP configured with ${mcpConfigs.servers.length} server(s)`, {
+      details,
+    });
+  }
+}
+
+module.exports = McpIntegrationCheck;