chati-dev 3.3.2 → 4.0.1

package/scripts/doctor/checks/registry.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Doctor check: Entity Registry integrity.
+ *
+ * Validates entity-registry.yaml exists, parses correctly,
+ * entity count matches metadata, and all entity paths exist.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Run entity registry integrity check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkRegistry(frameworkDir) {
+  const regPath = join(frameworkDir, 'data', 'entity-registry.yaml');
+  if (!existsSync(regPath)) {
+    return { pass: false, details: 'entity-registry.yaml not found', severity: 'critical', fixable: false, fixId: null };
+  }
+
+  try {
+    const content = readFileSync(regPath, 'utf8');
+    const registry = yaml.load(content);
+
+    if (!registry || !registry.entities) {
+      return { pass: false, details: 'entity-registry.yaml has no entities section', severity: 'critical', fixable: false, fixId: null };
+    }
+
+    // Count all entities across all categories
+    let entityCount = 0;
+    for (const category of Object.values(registry.entities)) {
+      if (typeof category === 'object' && category !== null) {
+        entityCount += Object.keys(category).length;
+      }
+    }
+
+    const declaredCount = registry.metadata?.entity_count || 0;
+    if (declaredCount > 0 && entityCount !== declaredCount) {
+      return {
+        pass: false,
+        details: `Entity count mismatch: declared ${declaredCount}, actual ${entityCount}`,
+        severity: 'warning',
+        fixable: true,
+        fixId: 'registry-count',
+      };
+    }
+
+    return { pass: true, details: `${entityCount} entities registered`, severity: 'info', fixable: false, fixId: null };
+  } catch (err) {
+    return { pass: false, details: `Failed to parse: ${err.message}`, severity: 'critical', fixable: false, fixId: null };
+  }
+}

package/scripts/doctor/checks/schemas.js

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview Doctor check: JSON Schema validation.
+ *
+ * Validates that all expected schema files exist and contain valid JSON.
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const EXPECTED_SCHEMAS = [
+  'session.schema.json',
+  'config.schema.json',
+  'context.schema.json',
+  'memory.schema.json',
+  'task.schema.json',
+];
+
+/**
+ * Run schema validation check.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ pass: boolean, details: string, severity: string, fixable: boolean, fixId: string|null }}
+ */
+export function checkSchemas(frameworkDir) {
+  const schemasDir = join(frameworkDir, 'schemas');
+  if (!existsSync(schemasDir)) {
+    return { pass: false, details: 'schemas/ directory not found', severity: 'critical', fixable: false, fixId: null };
+  }
+
+  const missing = [];
+  const invalid = [];
+
+  for (const schema of EXPECTED_SCHEMAS) {
+    const schemaPath = join(schemasDir, schema);
+    if (!existsSync(schemaPath)) {
+      missing.push(schema);
+      continue;
+    }
+    try {
+      JSON.parse(readFileSync(schemaPath, 'utf8'));
+    } catch {
+      invalid.push(schema);
+    }
+  }
+
+  if (missing.length > 0 || invalid.length > 0) {
+    const issues = [];
+    if (missing.length) issues.push(`missing: ${missing.join(', ')}`);
+    if (invalid.length) issues.push(`invalid JSON: ${invalid.join(', ')}`);
+    return {
+      pass: false,
+      details: issues.join('; '),
+      severity: missing.length > 0 ? 'critical' : 'warning',
+      fixable: false,
+      fixId: null,
+    };
+  }
+
+  const actualSchemas = readdirSync(schemasDir).filter(f => f.endsWith('.json'));
+  return { pass: true, details: `${actualSchemas.length} schemas valid`, severity: 'info', fixable: false, fixId: null };
+}

package/scripts/doctor/fixes/reference-fix.js

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview Doctor fix: Broken path references.
+ *
+ * Scans entity-registry.yaml for broken path references and
+ * attempts to locate the correct paths.
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Fix broken path references in entity-registry.yaml.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ fixed: boolean, details: string, fixedPaths: string[] }}
+ */
+export function fixBrokenReferences(frameworkDir) {
+  const regPath = join(frameworkDir, 'data', 'entity-registry.yaml');
+  if (!existsSync(regPath)) {
+    return { fixed: false, details: 'entity-registry.yaml not found', fixedPaths: [] };
+  }
+
+  try {
+    const content = readFileSync(regPath, 'utf8');
+    const registry = yaml.load(content);
+
+    if (!registry || !registry.entities) {
+      return { fixed: false, details: 'No entities section found', fixedPaths: [] };
+    }
+
+    const fixedPaths = [];
+    let updatedContent = content;
+
+    for (const category of Object.values(registry.entities)) {
+      for (const [name, entity] of Object.entries(category)) {
+        if (!entity.path) continue;
+
+        // Path in registry is relative to project root (e.g., "chati.dev/agents/...")
+        const relPath = entity.path.replace(/^chati\.dev\//, '');
+        const fullPath = join(frameworkDir, relPath);
+
+        if (existsSync(fullPath)) continue;
+
+        // Try to find the file by name
+        const fileName = basename(relPath);
+        const found = findFile(frameworkDir, fileName);
+
+        if (found) {
+          const newPath = 'chati.dev/' + found;
+          updatedContent = updatedContent.replace(
+            `path: ${entity.path}`,
+            `path: ${newPath}`
+          );
+          fixedPaths.push(`${name}: ${entity.path} -> ${newPath}`);
+        }
+      }
+    }
+
+    if (fixedPaths.length === 0) {
+      return { fixed: false, details: 'No broken references found', fixedPaths: [] };
+    }
+
+    writeFileSync(regPath, updatedContent, 'utf8');
+    return { fixed: true, details: `Fixed ${fixedPaths.length} path reference(s)`, fixedPaths };
+  } catch (err) {
+    return { fixed: false, details: `Fix failed: ${err.message}`, fixedPaths: [] };
+  }
+}
+
+/**
+ * Search for a file by name within the framework directory.
+ *
+ * @param {string} dir - Directory to search
+ * @param {string} fileName - File name to find
+ * @param {string} [prefix=''] - Path prefix for recursion
+ * @param {number} [depth=0] - Current depth
+ * @returns {string|null} Relative path from frameworkDir or null
+ */
+function findFile(dir, fileName, prefix = '', depth = 0) {
+  if (depth > 4) return null;
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isFile() && entry.name === fileName) {
+        return rel;
+      }
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+        const found = findFile(join(dir, entry.name), fileName, rel, depth + 1);
+        if (found) return found;
+      }
+    }
+  } catch {
+    // Permission error or inaccessible directory
+  }
+
+  return null;
+}

package/scripts/doctor/fixes/registry-fix.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Doctor fix: Registry count correction.
+ *
+ * Auto-fixes entity_count mismatch in entity-registry.yaml
+ * by counting actual entities and updating metadata.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Fix entity count mismatch in entity-registry.yaml.
+ *
+ * @param {string} frameworkDir - Path to framework directory
+ * @returns {{ fixed: boolean, details: string }}
+ */
+export function fixRegistryCount(frameworkDir) {
+  const regPath = join(frameworkDir, 'data', 'entity-registry.yaml');
+  if (!existsSync(regPath)) {
+    return { fixed: false, details: 'entity-registry.yaml not found' };
+  }
+
+  try {
+    const content = readFileSync(regPath, 'utf8');
+    const registry = yaml.load(content);
+
+    if (!registry || !registry.entities) {
+      return { fixed: false, details: 'No entities section found' };
+    }
+
+    // Count actual entities
+    let entityCount = 0;
+    for (const category of Object.values(registry.entities)) {
+      if (typeof category === 'object' && category !== null) {
+        entityCount += Object.keys(category).length;
+      }
+    }
+
+    const declaredCount = registry.metadata?.entity_count || 0;
+    if (entityCount === declaredCount) {
+      return { fixed: false, details: 'Entity count already correct' };
+    }
+
+    // Update the count using regex to preserve YAML formatting
+    const updatedContent = content.replace(
+      /entity_count:\s*\d+/,
+      `entity_count: ${entityCount}`
+    );
+
+    writeFileSync(regPath, updatedContent, 'utf8');
+    return { fixed: true, details: `Updated entity_count from ${declaredCount} to ${entityCount}` };
+  } catch (err) {
+    return { fixed: false, details: `Fix failed: ${err.message}` };
+  }
+}

package/scripts/doctor/index.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Doctor — Modular diagnostic system with auto-fix capability.
+ *
+ * Orchestrates individual check modules and fix modules to provide
+ * comprehensive framework health validation and automatic repair.
+ *
+ * Exports:
+ *   runDoctor(frameworkDir, options) → DoctorReport
+ *   formatDoctorReport(report) → human-readable string
+ *
+ * DoctorReport:
+ *   { overall, checks, fixes, timestamp, summary }
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+// Check modules
+import { checkRegistry } from './checks/registry.js';
+import { checkSchemas } from './checks/schemas.js';
+import { checkConstitution } from './checks/constitution.js';
+import { checkAgents } from './checks/agents.js';
+import { checkPrismLayers } from './checks/prism-layers.js';
+import { checkDomainAlignment } from './checks/domain-alignment.js';
+
+// Fix modules
+import { fixRegistryCount } from './fixes/registry-fix.js';
+import { fixBrokenReferences } from './fixes/reference-fix.js';
+
+/**
+ * Map of fixId to fix function.
+ */
+const FIX_REGISTRY = {
+  'registry-count': fixRegistryCount,
+  'broken-references': fixBrokenReferences,
+};
+
+/**
+ * All available check functions.
+ */
+const CHECK_REGISTRY = {
+  registry: checkRegistry,
+  schemas: checkSchemas,
+  constitution: checkConstitution,
+  agents: checkAgents,
+  prismLayers: checkPrismLayers,
+  domainAlignment: checkDomainAlignment,
+};
+
+/**
+ * Run the doctor diagnostic suite.
+ *
+ * @param {string} frameworkDir - Path to the framework directory
+ * @param {object} [options={}] - Configuration options
+ * @param {boolean} [options.fix=false] - Run auto-fix for fixable issues
+ * @param {string[]} [options.checks] - Specific checks to run (default: all)
+ * @returns {object} DoctorReport
+ */
+export function runDoctor(frameworkDir, options = {}) {
+  const { fix = false, checks: checkFilter } = options;
+
+  if (!existsSync(frameworkDir)) {
+    return {
+      overall: 'UNHEALTHY',
+      checks: {
+        frameworkDir: { pass: false, details: `Directory not found: ${frameworkDir}`, severity: 'critical', fixable: false, fixId: null },
+      },
+      fixes: [],
+      timestamp: new Date().toISOString(),
+      summary: { total: 1, passed: 0, failed: 1, criticalFailures: 1, warnings: 0, fixesApplied: 0 },
+    };
+  }
+
+  // Run checks
+  const checksToRun = checkFilter
+    ? Object.entries(CHECK_REGISTRY).filter(([name]) => checkFilter.includes(name))
+    : Object.entries(CHECK_REGISTRY);
+
+  const checkResults = {};
+  for (const [name, checkFn] of checksToRun) {
+    checkResults[name] = checkFn(frameworkDir);
+  }
+
+  // Run fixes if requested
+  const fixes = [];
+  if (fix) {
+    for (const [name, result] of Object.entries(checkResults)) {
+      if (!result.pass && result.fixable && result.fixId) {
+        const fixFn = FIX_REGISTRY[result.fixId];
+        if (fixFn) {
+          const fixResult = fixFn(frameworkDir);
+          fixes.push({ check: name, fixId: result.fixId, ...fixResult });
+
+          // Re-run the check if fix was applied
+          if (fixResult.fixed) {
+            const checkFn = CHECK_REGISTRY[name];
+            if (checkFn) {
+              checkResults[name] = checkFn(frameworkDir);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Determine overall health
+  const criticalFailures = Object.values(checkResults).filter(c => !c.pass && c.severity === 'critical');
+  const warnings = Object.values(checkResults).filter(c => !c.pass && c.severity === 'warning');
+
+  let overall;
+  if (criticalFailures.length > 0) {
+    overall = 'UNHEALTHY';
+  } else if (warnings.length > 0) {
+    overall = 'DEGRADED';
+  } else {
+    overall = 'HEALTHY';
+  }
+
+  return {
+    overall,
+    checks: checkResults,
+    fixes,
+    timestamp: new Date().toISOString(),
+    summary: {
+      total: Object.keys(checkResults).length,
+      passed: Object.values(checkResults).filter(c => c.pass).length,
+      failed: Object.values(checkResults).filter(c => !c.pass).length,
+      criticalFailures: criticalFailures.length,
+      warnings: warnings.length,
+      fixesApplied: fixes.filter(f => f.fixed).length,
+    },
+  };
+}
+
+/**
+ * Format a DoctorReport into a human-readable string.
+ *
+ * @param {object} report - DoctorReport from runDoctor
+ * @returns {string} Formatted report
+ */
+export function formatDoctorReport(report) {
+  const statusSymbol = {
+    HEALTHY: '[OK]',
+    DEGRADED: '[WARN]',
+    UNHEALTHY: '[FAIL]',
+  };
+
+  const checkSymbol = (check) => check.pass ? '[PASS]' : '[FAIL]';
+
+  const lines = [
+    '=== Doctor Report ===',
+    `Status: ${statusSymbol[report.overall] || '[ ? ]'} ${report.overall}`,
+    `Time:   ${report.timestamp}`,
+    '',
+  ];
+
+  if (report.summary) {
+    lines.push(`Summary: ${report.summary.passed}/${report.summary.total} checks passed`);
+    if (report.summary.criticalFailures > 0) {
+      lines.push(`         ${report.summary.criticalFailures} critical failure(s)`);
+    }
+    if (report.summary.warnings > 0) {
+      lines.push(`         ${report.summary.warnings} warning(s)`);
+    }
+    if (report.summary.fixesApplied > 0) {
+      lines.push(`         ${report.summary.fixesApplied} fix(es) applied`);
+    }
+    lines.push('');
+  }
+
+  lines.push('Checks:');
+  for (const [name, check] of Object.entries(report.checks)) {
+    const symbol = checkSymbol(check);
+    const severity = check.severity !== 'info' ? ` (${check.severity})` : '';
+    const fixable = check.fixable ? ' [fixable]' : '';
+    lines.push(`  ${symbol} ${name}: ${check.details}${severity}${fixable}`);
+  }
+
+  if (report.fixes && report.fixes.length > 0) {
+    lines.push('');
+    lines.push('Fixes:');
+    for (const fix of report.fixes) {
+      const symbol = fix.fixed ? '[FIXED]' : '[SKIP]';
+      lines.push(`  ${symbol} ${fix.check}: ${fix.details}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('=== End Report ===');
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// CLI entrypoint
+// ---------------------------------------------------------------------------
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const args = process.argv.slice(2);
+  const fix = args.includes('--fix');
+  const frameworkDir = args.find(a => !a.startsWith('--')) || join(process.cwd(), 'chati.dev');
+
+  const report = runDoctor(frameworkDir, { fix });
+  console.log(formatDoctorReport(report));
+
+  if (report.overall === 'UNHEALTHY') {
+    process.exit(1);
+  }
+}

package/scripts/health-check.js

@@ -146,14 +146,14 @@ function checkAgents(frameworkDir) {
   const orchestratorDir = join(frameworkDir, 'orchestrator');
 
   const expectedAgents = {
-    'planning/greenfield-wu.md': 'greenfield-wu',
-    'planning/brownfield-wu.md': 'brownfield-wu',
-    'planning/brief.md': 'brief',
-    'planning/detail.md': 'detail',
-    'planning/architect.md': 'architect',
-    'planning/ux.md': 'ux',
-    'planning/phases.md': 'phases',
-    'planning/tasks.md': 'tasks',
+    'discover/greenfield-wu.md': 'greenfield-wu',
+    'discover/brownfield-wu.md': 'brownfield-wu',
+    'discover/brief.md': 'brief',
+    'plan/detail.md': 'detail',
+    'plan/architect.md': 'architect',
+    'plan/ux.md': 'ux',
+    'plan/phases.md': 'phases',
+    'plan/tasks.md': 'tasks',
     'quality/qa-planning.md': 'qa-planning',
     'quality/qa-implementation.md': 'qa-implementation',
     'build/dev.md': 'dev',