aios-core 4.2.15 → 4.4.0

package/.aios-core/core/doctor/checks/code-intel.js

@@ -0,0 +1,131 @@
+/**
+ * Doctor Check: Code Intelligence
+ *
+ * Validates code-intel provider status by actually testing provider detection.
+ * Checks: module exists → registry-provider available → primitives work.
+ *
+ * @module aios-core/doctor/checks/code-intel
+ * @story INS-4.1, CODEINTEL-RP-001
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'code-intel';
+
+async function run(context) {
+  const codeIntelDir = path.join(context.projectRoot, '.aios-core', 'core', 'code-intel');
+
+  // Check 1: Module exists
+  if (!fs.existsSync(codeIntelDir)) {
+    return {
+      check: name,
+      status: 'INFO',
+      message: 'Code-intel module not found (optional)',
+      fixCommand: null,
+    };
+  }
+
+  // Check 2: Try to load and detect provider
+  try {
+    const indexPath = path.join(codeIntelDir, 'index.js');
+    if (!fs.existsSync(indexPath)) {
+      return {
+        check: name,
+        status: 'WARN',
+        message: 'Code-intel index.js not found',
+        fixCommand: null,
+      };
+    }
+
+    // Clear require cache to get fresh state
+    const resolvedIndex = require.resolve(indexPath);
+    delete require.cache[resolvedIndex];
+
+    const { getClient, isCodeIntelAvailable, _resetForTesting } = require(indexPath);
+
+    // Reset singleton to test fresh detection
+    _resetForTesting();
+
+    // Initialize client (triggers provider auto-detection)
+    const client = getClient({ projectRoot: context.projectRoot });
+    const available = isCodeIntelAvailable();
+    const metrics = client.getMetrics();
+
+    // Clean up singleton after test
+    _resetForTesting();
+
+    if (!available) {
+      // Check if entity-registry.yaml exists but provider still failed
+      const registryPath = path.join(context.projectRoot, '.aios-core', 'data', 'entity-registry.yaml');
+      if (fs.existsSync(registryPath)) {
+        const stat = fs.statSync(registryPath);
+        const sizeKB = Math.round(stat.size / 1024);
+        return {
+          check: name,
+          status: 'WARN',
+          message: `Registry exists (${sizeKB}KB) but provider detection failed — may be empty or malformed`,
+          fixCommand: 'node .aios-core/development/scripts/populate-entity-registry.js',
+        };
+      }
+
+      return {
+        check: name,
+        status: 'INFO',
+        message: 'No provider available (no registry, no MCP) — graceful fallback active',
+        fixCommand: 'node .aios-core/development/scripts/populate-entity-registry.js',
+      };
+    }
+
+    // Provider is available — report details
+    const provider = metrics.activeProvider;
+    const cbState = metrics.circuitBreakerState;
+
+    if (provider === 'registry') {
+      // Read entity count from registry metadata
+      const registryPath = path.join(context.projectRoot, '.aios-core', 'data', 'entity-registry.yaml');
+      let entityInfo = '';
+      if (fs.existsSync(registryPath)) {
+        const content = fs.readFileSync(registryPath, 'utf8');
+        const sizeKB = Math.round(fs.statSync(registryPath).size / 1024);
+        // Extract entityCount from metadata header (avoids full YAML parse)
+        const countMatch = content.match(/entityCount:\s*(\d+)/);
+        const entityCount = countMatch ? countMatch[1] : '?';
+        entityInfo = `, ${entityCount} entities, ${sizeKB}KB`;
+      }
+
+      return {
+        check: name,
+        status: 'PASS',
+        message: `RegistryProvider (T1) active, 5/8 primitives${entityInfo}, CB: ${cbState}`,
+        fixCommand: null,
+      };
+    }
+
+    if (provider === 'code-graph') {
+      return {
+        check: name,
+        status: 'PASS',
+        message: `CodeGraphProvider (T3/MCP) active, 8/8 primitives, CB: ${cbState}`,
+        fixCommand: null,
+      };
+    }
+
+    // Unknown provider (custom)
+    return {
+      check: name,
+      status: 'PASS',
+      message: `Provider '${provider}' active, CB: ${cbState}`,
+      fixCommand: null,
+    };
+  } catch (error) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: `Provider detection error: ${error.message}`,
+      fixCommand: null,
+    };
+  }
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/commands-count.js

@@ -0,0 +1,81 @@
+/**
+ * Doctor Check: Commands Count
+ *
+ * Counts .md files in .claude/commands/ recursively.
+ * PASS: >=20, WARN: 12-19, FAIL: <12.
+ *
+ * @module aios-core/doctor/checks/commands-count
+ * @story INS-4.8
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'commands-count';
+
+/**
+ * Recursively count .md files in a directory.
+ */
+function countMdFiles(dir) {
+  let count = 0;
+  let entries;
+
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      count += countMdFiles(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      count++;
+    }
+  }
+
+  return count;
+}
+
+async function run(context) {
+  const commandsDir = path.join(context.projectRoot, '.claude', 'commands');
+
+  if (!fs.existsSync(commandsDir)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Commands directory not found (.claude/commands/)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const count = countMdFiles(commandsDir);
+
+  if (count >= 20) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: `${count} command files found`,
+      fixCommand: null,
+    };
+  }
+
+  if (count >= 12) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: `${count}/20 command files found (agents only, no extras)`,
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  return {
+    check: name,
+    status: 'FAIL',
+    message: `Only ${count} command files found (expected >=12)`,
+    fixCommand: 'npx aios-core install --force',
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/core-config.js

@@ -0,0 +1,53 @@
+/**
+ * Doctor Check: Core Config
+ *
+ * Validates core-config.yaml exists and has required keys:
+ * boundary, project, ide.
+ *
+ * @module aios-core/doctor/checks/core-config
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'core-config';
+
+const REQUIRED_SECTIONS = ['boundary', 'project', 'ide'];
+
+async function run(context) {
+  const configPath = path.join(context.projectRoot, '.aios-core', 'core-config.yaml');
+
+  if (!fs.existsSync(configPath)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'core-config.yaml not found',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const content = fs.readFileSync(configPath, 'utf8');
+
+  const missingSections = REQUIRED_SECTIONS.filter(
+    (section) => !content.includes(`${section}:`),
+  );
+
+  if (missingSections.length === 0) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: 'Schema valid, boundary section present',
+      fixCommand: null,
+    };
+  }
+
+  return {
+    check: name,
+    status: 'FAIL',
+    message: `Missing sections: ${missingSections.join(', ')}`,
+    fixCommand: 'npx aios-core install --force',
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/entity-registry.js

@@ -0,0 +1,53 @@
+/**
+ * Doctor Check: Entity Registry
+ *
+ * Validates .aios-core/data/entity-registry.yaml exists and mtime < 48h.
+ *
+ * @module aios-core/doctor/checks/entity-registry
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'entity-registry';
+
+const MAX_AGE_MS = 48 * 60 * 60 * 1000; // 48 hours
+
+async function run(context) {
+  const registryPath = path.join(context.projectRoot, '.aios-core', 'data', 'entity-registry.yaml');
+
+  if (!fs.existsSync(registryPath)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'entity-registry.yaml not found',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const stat = fs.statSync(registryPath);
+  const ageMs = Date.now() - stat.mtimeMs;
+  const ageHours = Math.round(ageMs / (60 * 60 * 1000));
+
+  const content = fs.readFileSync(registryPath, 'utf8');
+  const lineCount = content.split('\n').length;
+
+  if (ageMs > MAX_AGE_MS) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: `entity-registry.yaml is ${ageHours}h old (threshold: 48h), ~${lineCount} lines`,
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  return {
+    check: name,
+    status: 'PASS',
+    message: `~${lineCount} lines, updated ${ageHours}h ago`,
+    fixCommand: null,
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/git-hooks.js

@@ -0,0 +1,50 @@
+/**
+ * Doctor Check: Git Hooks
+ *
+ * Validates .husky/pre-commit and .husky/pre-push exist.
+ *
+ * @module aios-core/doctor/checks/git-hooks
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'git-hooks';
+
+const EXPECTED_HOOKS = ['pre-commit', 'pre-push'];
+
+async function run(context) {
+  const huskyDir = path.join(context.projectRoot, '.husky');
+
+  if (!fs.existsSync(huskyDir)) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: '.husky directory not found',
+      fixCommand: 'npx husky init',
+    };
+  }
+
+  const missing = EXPECTED_HOOKS.filter(
+    (hook) => !fs.existsSync(path.join(huskyDir, hook)),
+  );
+
+  if (missing.length === 0) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: `${EXPECTED_HOOKS.join(' + ')} installed`,
+      fixCommand: null,
+    };
+  }
+
+  return {
+    check: name,
+    status: 'WARN',
+    message: `Missing hooks: ${missing.join(', ')}`,
+    fixCommand: 'npx husky init',
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/graph-dashboard.js

@@ -0,0 +1,48 @@
+/**
+ * Doctor Check: Graph Dashboard
+ *
+ * Validates .aios-core/core/graph-dashboard/ directory exists
+ * with at least 1 .js file.
+ *
+ * @module aios-core/doctor/checks/graph-dashboard
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'graph-dashboard';
+
+async function run(context) {
+  const dashboardDir = path.join(context.projectRoot, '.aios-core', 'core', 'graph-dashboard');
+
+  if (!fs.existsSync(dashboardDir)) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: 'graph-dashboard directory not found',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const jsFiles = fs.readdirSync(dashboardDir)
+    .filter((f) => f.endsWith('.js'));
+
+  if (jsFiles.length === 0) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: 'graph-dashboard directory empty (no .js files)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  return {
+    check: name,
+    status: 'PASS',
+    message: `All modules present (${jsFiles.length} files)`,
+    fixCommand: null,
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/hooks-claude-count.js

@@ -0,0 +1,118 @@
+/**
+ * Doctor Check: Hooks Claude Count
+ *
+ * Counts .cjs files in .claude/hooks/ and verifies registration
+ * in settings.local.json.
+ * PASS: >=2 + all registered, WARN: files present but not registered or <2,
+ * FAIL: 0 or directory missing.
+ *
+ * @module aios-core/doctor/checks/hooks-claude-count
+ * @story INS-4.8
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'hooks-claude-count';
+
+async function run(context) {
+  const hooksDir = path.join(context.projectRoot, '.claude', 'hooks');
+
+  if (!fs.existsSync(hooksDir)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Hooks directory not found (.claude/hooks/)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(hooksDir, { withFileTypes: true });
+  } catch {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Cannot read hooks directory',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const hookFiles = entries.filter(
+    (e) => e.isFile() && e.name.endsWith('.cjs'),
+  );
+  const hookCount = hookFiles.length;
+
+  if (hookCount === 0) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'No hook files found (.cjs)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  // Check registration in settings.local.json
+  const settingsLocalPath = path.join(context.projectRoot, '.claude', 'settings.local.json');
+  let registered = false;
+
+  if (fs.existsSync(settingsLocalPath)) {
+    try {
+      const settingsLocal = JSON.parse(fs.readFileSync(settingsLocalPath, 'utf8'));
+      const hooks = settingsLocal.hooks || {};
+      // Claude Code hooks schema: { EventName: [{ matcher, hooks: [{ type, command }] }] }
+      const allHookCommands = [];
+      for (const entries of Object.values(hooks)) {
+        if (!Array.isArray(entries)) continue;
+        for (const entry of entries) {
+          if (entry && Array.isArray(entry.hooks)) {
+            for (const h of entry.hooks) {
+              if (h && h.command) allHookCommands.push(h.command);
+            }
+          }
+          // Fallback: flat string or direct command
+          if (typeof entry === 'string') allHookCommands.push(entry);
+          if (entry && typeof entry.command === 'string') allHookCommands.push(entry.command);
+        }
+      }
+      const hooksStr = allHookCommands.join('\n');
+
+      // Check if at least some hook files are referenced in settings
+      const referencedCount = hookFiles.filter(
+        (f) => hooksStr.includes(f.name) || hooksStr.includes(f.name.replace('.cjs', '')),
+      ).length;
+
+      registered = referencedCount > 0;
+    } catch {
+      registered = false;
+    }
+  }
+
+  if (hookCount >= 2 && registered) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: `${hookCount} hook files found and registered`,
+      fixCommand: null,
+    };
+  }
+
+  if (hookCount >= 2 && !registered) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: `${hookCount} hook files found but not registered in settings.local.json`,
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  return {
+    check: name,
+    status: 'WARN',
+    message: `Only ${hookCount}/2 hook files found`,
+    fixCommand: 'npx aios-core install --force',
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/ide-sync.js

@@ -0,0 +1,85 @@
+/**
+ * Doctor Check: IDE Sync
+ *
+ * Validates agents in .claude/commands/AIOS/agents/ match
+ * .aios-core/development/agents/ (count and names).
+ *
+ * @module aios-core/doctor/checks/ide-sync
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'ide-sync';
+
+async function run(context) {
+  const agentsSourceDir = path.join(context.projectRoot, '.aios-core', 'development', 'agents');
+  const agentsIdeDir = path.join(context.projectRoot, '.claude', 'commands', 'AIOS', 'agents');
+
+  if (!fs.existsSync(agentsSourceDir)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Source agents directory not found',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  if (!fs.existsSync(agentsIdeDir)) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: 'IDE agents directory not found (.claude/commands/AIOS/agents/)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  let sourceAgents, ideFiles;
+  try {
+    sourceAgents = fs.readdirSync(agentsSourceDir)
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => f.replace('.md', ''));
+  } catch (_err) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Cannot read source agents directory',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  try {
+    ideFiles = fs.readdirSync(agentsIdeDir)
+      .filter((f) => f.endsWith('.md'));
+  } catch (_err) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: 'Cannot read IDE agents directory',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const ideAgents = ideFiles.map((f) => f.replace('.md', ''));
+  const sourceCount = sourceAgents.length;
+  const ideCount = ideAgents.length;
+
+  if (sourceCount === ideCount) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: `${ideCount}/${sourceCount} agents synced`,
+      fixCommand: null,
+    };
+  }
+
+  return {
+    check: name,
+    status: 'WARN',
+    message: `IDE has ${ideCount} agents, source has ${sourceCount}`,
+    fixCommand: 'npx aios-core install --force',
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/checks/index.js

@@ -0,0 +1,46 @@
+/**
+ * Doctor Check Registry
+ *
+ * Exports all 15 check modules in execution order.
+ *
+ * @module aios-core/doctor/checks
+ * @story INS-4.1, INS-4.8
+ */
+
+const settingsJson = require('./settings-json');
+const rulesFiles = require('./rules-files');
+const agentMemory = require('./agent-memory');
+const entityRegistry = require('./entity-registry');
+const gitHooks = require('./git-hooks');
+const coreConfig = require('./core-config');
+const claudeMd = require('./claude-md');
+const ideSync = require('./ide-sync');
+const graphDashboard = require('./graph-dashboard');
+const codeIntel = require('./code-intel');
+const nodeVersion = require('./node-version');
+const npmPackages = require('./npm-packages');
+const skillsCount = require('./skills-count');
+const commandsCount = require('./commands-count');
+const hooksClaudeCount = require('./hooks-claude-count');
+
+function loadChecks() {
+  return [
+    settingsJson,
+    rulesFiles,
+    agentMemory,
+    entityRegistry,
+    gitHooks,
+    coreConfig,
+    claudeMd,
+    ideSync,
+    graphDashboard,
+    codeIntel,
+    nodeVersion,
+    npmPackages,
+    skillsCount,
+    commandsCount,
+    hooksClaudeCount,
+  ];
+}
+
+module.exports = { loadChecks };

package/.aios-core/core/doctor/checks/node-version.js

@@ -0,0 +1,33 @@
+/**
+ * Doctor Check: Node.js Version
+ *
+ * Validates Node.js >= 18 via process.version.
+ *
+ * @module aios-core/doctor/checks/node-version
+ * @story INS-4.1
+ */
+
+const name = 'node-version';
+
+async function run() {
+  const version = process.version.replace('v', '');
+  const [major] = version.split('.').map(Number);
+
+  if (major >= 18) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: `Node.js ${process.version}`,
+      fixCommand: null,
+    };
+  }
+
+  return {
+    check: name,
+    status: 'FAIL',
+    message: `Node.js ${process.version} (requires >= 18.0.0)`,
+    fixCommand: 'nvm install 20 && nvm use 20',
+  };
+}
+
+module.exports = { name, run };