aios-core 4.2.14 → 4.3.0

package/.aios-core/core/doctor/checks/settings-json.js

@@ -0,0 +1,121 @@
+/**
+ * Doctor Check: settings.json
+ *
+ * Validates .claude/settings.json exists, deny rules count >= 40,
+ * and compares against core-config.yaml boundary paths.
+ *
+ * @module aios-core/doctor/checks/settings-json
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'settings-json';
+
+/**
+ * Checks that core-config.yaml boundary.protected paths are covered by deny rules.
+ * Returns array of unprotected boundary paths.
+ */
+function checkBoundaryAlignment(context, denyRules) {
+  const configPath = path.join(context.projectRoot, '.aios-core', 'core-config.yaml');
+  if (!fs.existsSync(configPath)) return []; // No config = skip boundary check
+
+  let content;
+  try {
+    content = fs.readFileSync(configPath, 'utf8');
+  } catch {
+    return [];
+  }
+
+  // Extract boundary.protected paths from YAML (simple line parsing)
+  const lines = content.split('\n');
+  const protectedPaths = [];
+  let inProtected = false;
+
+  for (const line of lines) {
+    if (/^\s+protected:\s*$/.test(line)) {
+      inProtected = true;
+      continue;
+    }
+    if (inProtected) {
+      const match = line.match(/^\s+-\s+(.+)$/);
+      if (match) {
+        protectedPaths.push(match[1].trim());
+      } else if (/^\s+\w/.test(line) && !line.match(/^\s+-/)) {
+        inProtected = false;
+      }
+    }
+  }
+
+  if (protectedPaths.length === 0) return [];
+
+  // Check each boundary path has at least one matching deny rule
+  const denyStr = denyRules.join('\n');
+  const unprotected = protectedPaths.filter((bp) => {
+    // Strip glob suffixes for base path matching
+    const basePath = bp.replace(/\/\*\*$/, '').replace(/\/\*$/, '');
+    return !denyStr.includes(basePath);
+  });
+
+  return unprotected;
+}
+
+async function run(context) {
+  const settingsPath = path.join(context.projectRoot, '.claude', 'settings.json');
+
+  if (!fs.existsSync(settingsPath)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'settings.json not found',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'settings.json is invalid JSON',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const denyRules = settings.permissions?.deny || [];
+  const allowRules = settings.permissions?.allow || [];
+  const denyCount = denyRules.length;
+  const allowCount = allowRules.length;
+
+  if (denyCount < 40) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: `Deny rules below threshold (${denyCount} rules, expected >= 40)`,
+      fixCommand: 'aios doctor --fix',
+    };
+  }
+
+  // Compare deny rules against core-config.yaml boundary.protected paths
+  const boundaryIssues = checkBoundaryAlignment(context, denyRules);
+  if (boundaryIssues.length > 0) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: `Deny rules present (${denyCount}) but missing boundary coverage: ${boundaryIssues.join(', ')}`,
+      fixCommand: 'aios doctor --fix',
+    };
+  }
+
+  return {
+    check: name,
+    status: 'PASS',
+    message: `Deny rules present (${denyCount} rules, ${allowCount} allows)`,
+    fixCommand: null,
+  };
+}
+
+module.exports = { name, run };

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

@@ -0,0 +1,72 @@
+/**
+ * Doctor Check: Skills Count
+ *
+ * Counts skill directories in .claude/skills/ that contain SKILL.md.
+ * PASS: >=7, WARN: 1-6, FAIL: 0 or directory missing.
+ *
+ * @module aios-core/doctor/checks/skills-count
+ * @story INS-4.8
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'skills-count';
+
+async function run(context) {
+  const skillsDir = path.join(context.projectRoot, '.claude', 'skills');
+
+  if (!fs.existsSync(skillsDir)) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Skills directory not found (.claude/skills/)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Cannot read skills directory',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  const skills = entries.filter(
+    (d) => d.isDirectory() && fs.existsSync(path.join(skillsDir, d.name, 'SKILL.md')),
+  );
+
+  const count = skills.length;
+
+  if (count === 0) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'No skills found (expected >=7)',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
+
+  if (count >= 7) {
+    return {
+      check: name,
+      status: 'PASS',
+      message: `${count} skills found`,
+      fixCommand: null,
+    };
+  }
+
+  return {
+    check: name,
+    status: 'WARN',
+    message: `Only ${count}/7 skills found`,
+    fixCommand: 'npx aios-core install --force',
+  };
+}
+
+module.exports = { name, run };

package/.aios-core/core/doctor/fix-handler.js

@@ -0,0 +1,165 @@
+/**
+ * Doctor Fix Handler
+ *
+ * Maps check names to fix functions. Supports --fix and --dry-run modes.
+ * All fix operations are idempotent.
+ *
+ * @module aios-core/doctor/fix-handler
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const { EXPECTED_RULES } = require('./checks/rules-files');
+const { EXPECTED_AGENTS } = require('./checks/agent-memory');
+
+/**
+ * Apply fixes for WARN/FAIL results
+ *
+ * @param {Array} results - Check results
+ * @param {Object} context - Doctor context
+ * @returns {Array} Fix results
+ */
+async function applyFixes(results, context) {
+  const { projectRoot, frameworkRoot, options } = context;
+  const { dryRun = false } = options;
+  const fixResults = [];
+
+  for (const result of results) {
+    if (result.status !== 'WARN' && result.status !== 'FAIL') {
+      continue;
+    }
+
+    const fixer = FIX_MAP[result.check];
+    if (!fixer) {
+      fixResults.push({
+        check: result.check,
+        applied: false,
+        message: 'No auto-fix available',
+      });
+      continue;
+    }
+
+    try {
+      if (dryRun) {
+        const description = fixer.describe(result, { projectRoot, frameworkRoot });
+        fixResults.push({
+          check: result.check,
+          applied: false,
+          message: `[DRY RUN] Would: ${description}`,
+        });
+      } else {
+        const fixMessage = await fixer.apply(result, { projectRoot, frameworkRoot });
+        fixResults.push({
+          check: result.check,
+          applied: true,
+          message: fixMessage,
+        });
+      }
+    } catch (error) {
+      fixResults.push({
+        check: result.check,
+        applied: false,
+        message: `Fix failed: ${error.message}`,
+      });
+    }
+  }
+
+  return fixResults;
+}
+
+const FIX_MAP = {
+  'rules-files': {
+    describe(result, { projectRoot, frameworkRoot }) {
+      const rulesSource = path.join(frameworkRoot, '.claude', 'rules');
+      const rulesTarget = path.join(projectRoot, '.claude', 'rules');
+      return `Copy missing rules from ${rulesSource} to ${rulesTarget}`;
+    },
+    async apply(result, { projectRoot, frameworkRoot }) {
+      const rulesSource = path.join(frameworkRoot, '.claude', 'rules');
+      const rulesTarget = path.join(projectRoot, '.claude', 'rules');
+
+      if (!fs.existsSync(rulesTarget)) {
+        fs.mkdirSync(rulesTarget, { recursive: true });
+      }
+
+      let copied = 0;
+      for (const file of EXPECTED_RULES) {
+        const targetFile = path.join(rulesTarget, file);
+        const sourceFile = path.join(rulesSource, file);
+
+        if (!fs.existsSync(targetFile) && fs.existsSync(sourceFile)) {
+          fs.copyFileSync(sourceFile, targetFile);
+          copied++;
+        }
+      }
+
+      return `Copied ${copied} missing rules files`;
+    },
+  },
+
+  'agent-memory': {
+    describe() {
+      return 'Create missing MEMORY.md stubs for agents';
+    },
+    async apply(result, { projectRoot }) {
+      const agentsDir = path.join(projectRoot, '.aios-core', 'development', 'agents');
+      let created = 0;
+
+      for (const agent of EXPECTED_AGENTS) {
+        const memoryPath = path.join(agentsDir, agent, 'MEMORY.md');
+        const agentDir = path.join(agentsDir, agent);
+
+        if (!fs.existsSync(memoryPath)) {
+          if (!fs.existsSync(agentDir)) {
+            fs.mkdirSync(agentDir, { recursive: true });
+          }
+          fs.writeFileSync(memoryPath, `# ${agent} Agent Memory\n\n_Created by aios doctor --fix_\n`);
+          created++;
+        }
+      }
+
+      return `Created ${created} MEMORY.md stubs`;
+    },
+  },
+
+  'claude-md': {
+    describe() {
+      return 'Regenerate CLAUDE.md with missing sections';
+    },
+    async apply() {
+      return 'CLAUDE.md regeneration requires npx aios-core install --force';
+    },
+  },
+
+  'settings-json': {
+    describe() {
+      return 'Regenerate settings.json with boundary deny rules';
+    },
+    async apply(result, { frameworkRoot }) {
+      const generatorPath = path.join(
+        frameworkRoot,
+        'packages',
+        'installer',
+        'src',
+        'generators',
+        'generate-settings-json',
+      );
+
+      try {
+        const generator = require(generatorPath);
+        if (typeof generator.generateSettingsJson === 'function') {
+          await generator.generateSettingsJson();
+          return 'settings.json regenerated';
+        }
+      } catch {
+        // Generator not available
+      }
+
+      return 'settings.json regeneration requires npx aios-core install --force';
+    },
+  },
+};
+
+module.exports = { applyFixes };

package/.aios-core/core/doctor/formatters/json.js

@@ -0,0 +1,14 @@
+/**
+ * Doctor JSON Formatter
+ *
+ * Formats doctor results as structured JSON.
+ *
+ * @module aios-core/doctor/formatters/json
+ * @story INS-4.1
+ */
+
+function formatJson(output) {
+  return JSON.stringify(output, null, 2);
+}
+
+module.exports = { formatJson };

package/.aios-core/core/doctor/formatters/text.js

@@ -0,0 +1,59 @@
+/**
+ * Doctor Text Formatter
+ *
+ * Formats doctor results as human-readable text output.
+ *
+ * @module aios-core/doctor/formatters/text
+ * @story INS-4.1
+ */
+
+const STATUS_PREFIX = {
+  PASS: '[PASS]',
+  WARN: '[WARN]',
+  FAIL: '[FAIL]',
+  INFO: '[INFO]',
+};
+
+function formatText(output, options = {}) {
+  const { quiet = false } = options;
+  const lines = [];
+
+  lines.push(`AIOS Doctor v${output.version} — Environment Health Check`);
+  lines.push('');
+
+  for (const result of output.checks) {
+    const prefix = STATUS_PREFIX[result.status] || '[????]';
+    lines.push(`  ${prefix} ${result.check}: ${result.message}`);
+  }
+
+  lines.push('');
+  const { pass, warn, fail, info } = output.summary;
+  lines.push(`Summary: ${pass} PASS | ${warn} WARN | ${fail} FAIL | ${info} INFO`);
+
+  if (!quiet) {
+    const fixable = output.checks.filter(
+      (r) => (r.status === 'WARN' || r.status === 'FAIL') && r.fixCommand,
+    );
+
+    if (fixable.length > 0) {
+      lines.push('');
+      lines.push('Fix suggestions:');
+      fixable.forEach((r, i) => {
+        lines.push(`  ${i + 1}. [${r.status}] ${r.check}: Run \`${r.fixCommand}\``);
+      });
+    }
+  }
+
+  if (output.fixResults) {
+    lines.push('');
+    lines.push('Fix results:');
+    for (const fr of output.fixResults) {
+      const icon = fr.applied ? '✓' : '✗';
+      lines.push(`  ${icon} ${fr.check}: ${fr.message}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { formatText };

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

@@ -0,0 +1,94 @@
+/**
+ * AIOS Doctor — Environment Health Check Orchestrator
+ *
+ * Runs 12 modular checks against the AIOS environment and returns
+ * structured results with optional --fix, --json, and --dry-run support.
+ *
+ * @module aios-core/doctor
+ * @version 2.0.0
+ * @story INS-4.1
+ */
+
+const path = require('path');
+const { loadChecks } = require('./checks');
+const { formatText } = require('./formatters/text');
+const { formatJson } = require('./formatters/json');
+const { applyFixes } = require('./fix-handler');
+
+const DOCTOR_VERSION = '2.0.0';
+
+/**
+ * Run all doctor checks
+ *
+ * @param {Object} options
+ * @param {boolean} [options.fix=false] - Auto-correct fixable issues
+ * @param {boolean} [options.json=false] - Output as JSON
+ * @param {boolean} [options.dryRun=false] - Show what --fix would do
+ * @param {boolean} [options.quiet=false] - Minimal output
+ * @param {string} [options.projectRoot] - Project root (defaults to cwd)
+ * @returns {Promise<Object>} Doctor results
+ */
+async function runDoctorChecks(options = {}) {
+  const {
+    fix = false,
+    json = false,
+    dryRun = false,
+    quiet = false,
+    projectRoot = process.cwd(),
+  } = options;
+
+  const context = {
+    projectRoot,
+    frameworkRoot: path.resolve(__dirname, '..', '..', '..'),
+    options: { fix, json, dryRun, quiet },
+  };
+
+  // Load and run all checks
+  const checks = loadChecks();
+  const results = [];
+
+  for (const checkModule of checks) {
+    try {
+      const result = await checkModule.run(context);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        check: checkModule.name || 'unknown',
+        status: 'FAIL',
+        message: `Check threw error: ${error.message}`,
+        fixCommand: null,
+      });
+    }
+  }
+
+  // Apply fixes if requested
+  let fixResults = null;
+  if (fix || dryRun) {
+    fixResults = await applyFixes(results, context);
+  }
+
+  // Build summary
+  const summary = {
+    pass: results.filter((r) => r.status === 'PASS').length,
+    warn: results.filter((r) => r.status === 'WARN').length,
+    fail: results.filter((r) => r.status === 'FAIL').length,
+    info: results.filter((r) => r.status === 'INFO').length,
+  };
+
+  const output = {
+    version: DOCTOR_VERSION,
+    timestamp: new Date().toISOString(),
+    summary,
+    checks: results,
+    fixResults,
+  };
+
+  // Format output
+  if (json) {
+    return { formatted: formatJson(output), data: output };
+  }
+
+  return { formatted: formatText(output, { quiet }), data: output };
+}
+
+module.exports = { runDoctorChecks, DOCTOR_VERSION };