chati-dev 2.0.5 → 2.0.7

package/scripts/semantic-lint.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+/**
+ * Semantic Linter — Validates cross-reference consistency across the framework.
+ *
+ * Goes beyond structural validation (validate-agents, validate-tasks) to check
+ * semantic consistency: entity registry integrity, domain-agent alignment,
+ * workflow references, i18n completeness, schema existence, constitution articles.
+ *
+ * Exports:
+ *   semanticLint(frameworkDir) → { errors, warnings, checks, passed }
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Check that all paths in entity-registry.yaml point to existing files.
+ */
+function checkEntityRegistryIntegrity(frameworkDir, results) {
+  results.checks++;
+  const registryPath = join(frameworkDir, 'data', 'entity-registry.yaml');
+
+  if (!existsSync(registryPath)) {
+    results.errors.push('Entity registry not found at data/entity-registry.yaml');
+    return;
+  }
+
+  const registry = yaml.load(readFileSync(registryPath, 'utf-8'));
+  const entities = registry.entities || {};
+  let total = 0;
+  let found = 0;
+  const missing = [];
+
+  for (const category of Object.values(entities)) {
+    for (const [name, entity] of Object.entries(category)) {
+      if (!entity.path) continue;
+      total++;
+
+      // Path in registry is relative to project root (e.g., "chati.dev/agents/...")
+      // Strip "chati.dev/" prefix to get path relative to frameworkDir
+      const relPath = entity.path.replace(/^chati\.dev\//, '');
+      if (existsSync(join(frameworkDir, relPath))) {
+        found++;
+      } else {
+        missing.push(`${name}: ${entity.path}`);
+      }
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+    results.details.push(`Entity registry integrity: ${found}/${total} paths exist`);
+  } else {
+    results.errors.push(`Entity registry: ${missing.length} missing files — ${missing.slice(0, 5).join('; ')}${missing.length > 5 ? '...' : ''}`);
+  }
+}
+
+/**
+ * Check that each agent in domains/agents/ has a corresponding agent definition file.
+ */
+function checkDomainAgentAlignment(frameworkDir, results) {
+  results.checks++;
+  const domainsDir = join(frameworkDir, 'domains', 'agents');
+
+  if (!existsSync(domainsDir)) {
+    results.errors.push('Domain agents directory not found at domains/agents/');
+    return;
+  }
+
+  const domainFiles = readdirSync(domainsDir).filter(f => f.endsWith('.yaml'));
+  const mismatches = [];
+
+  for (const file of domainFiles) {
+    const agentName = basename(file, '.yaml');
+
+    // orchestrator has a different path
+    if (agentName === 'orchestrator') {
+      if (!existsSync(join(frameworkDir, 'orchestrator', 'chati.md'))) {
+        mismatches.push('orchestrator');
+      }
+      continue;
+    }
+
+    // Other agents: check all category dirs
+    const agentDirs = ['agents/planning', 'agents/quality', 'agents/build', 'agents/deploy'];
+    const found = agentDirs.some(dir =>
+      existsSync(join(frameworkDir, dir, `${agentName}.md`))
+    );
+
+    if (!found) {
+      mismatches.push(agentName);
+    }
+  }
+
+  if (mismatches.length === 0) {
+    results.passed++;
+    results.details.push(`Domain-agent alignment: ${domainFiles.length}/${domainFiles.length} agents matched`);
+  } else {
+    results.errors.push(`Domain-agent mismatch: ${mismatches.join(', ')} have domain YAML but no agent .md`);
+  }
+}
+
+/**
+ * Check that i18n files have consistent keys across all languages.
+ */
+function checkI18nCompleteness(frameworkDir, results) {
+  results.checks++;
+  const i18nDir = join(frameworkDir, 'i18n');
+
+  if (!existsSync(i18nDir)) {
+    results.errors.push('i18n directory not found');
+    return;
+  }
+
+  const languages = ['en', 'pt', 'es', 'fr'];
+  const keysByLang = {};
+
+  for (const lang of languages) {
+    const filePath = join(i18nDir, `${lang}.yaml`);
+    if (!existsSync(filePath)) {
+      results.errors.push(`i18n file missing: ${lang}.yaml`);
+      return;
+    }
+
+    const content = yaml.load(readFileSync(filePath, 'utf-8'));
+    keysByLang[lang] = flattenKeys(content);
+  }
+
+  // Use 'en' as reference
+  const refKeys = new Set(keysByLang.en);
+  const missingByLang = {};
+
+  for (const lang of languages) {
+    if (lang === 'en') continue;
+    const langKeys = new Set(keysByLang[lang]);
+
+    for (const key of refKeys) {
+      // Skip non-translatable keys
+      if (key === 'language' || key === 'name') continue;
+
+      if (!langKeys.has(key)) {
+        if (!missingByLang[lang]) missingByLang[lang] = [];
+        missingByLang[lang].push(key);
+      }
+    }
+  }
+
+  const totalMissing = Object.values(missingByLang).reduce((sum, arr) => sum + arr.length, 0);
+
+  if (totalMissing === 0) {
+    results.passed++;
+    results.details.push(`i18n completeness: all ${languages.length} languages have consistent keys`);
+  } else {
+    for (const [lang, keys] of Object.entries(missingByLang)) {
+      results.warnings.push(`i18n: '${lang}' missing ${keys.length} key(s): ${keys.slice(0, 3).join(', ')}${keys.length > 3 ? '...' : ''}`);
+    }
+    results.passed++; // warnings don't fail the check
+  }
+}
+
+/**
+ * Check that all expected schema files exist.
+ */
+function checkSchemaExistence(frameworkDir, results) {
+  results.checks++;
+  const schemasDir = join(frameworkDir, 'schemas');
+  const expectedSchemas = [
+    'session.schema.json', 'config.schema.json', 'task.schema.json',
+    'context.schema.json', 'memory.schema.json',
+  ];
+
+  const missing = expectedSchemas.filter(s => !existsSync(join(schemasDir, s)));
+
+  if (missing.length === 0) {
+    results.passed++;
+    results.details.push(`Schema existence: ${expectedSchemas.length}/${expectedSchemas.length} schemas found`);
+  } else {
+    results.errors.push(`Missing schemas: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Check constitution has >= 17 articles.
+ */
+function checkConstitution(frameworkDir, results) {
+  results.checks++;
+  const constitutionPath = join(frameworkDir, 'constitution.md');
+
+  if (!existsSync(constitutionPath)) {
+    results.errors.push('constitution.md not found');
+    return;
+  }
+
+  const content = readFileSync(constitutionPath, 'utf-8');
+  const articleCount = (content.match(/^## Article/gm) || []).length;
+
+  if (articleCount >= 17) {
+    results.passed++;
+    results.details.push(`Constitution: ${articleCount} articles found`);
+  } else {
+    results.errors.push(`Constitution has only ${articleCount} articles (expected >= 17)`);
+  }
+}
+
+/**
+ * Check that workflow files reference valid agents.
+ */
+function checkWorkflowAgentRefs(frameworkDir, results) {
+  results.checks++;
+  const workflowsDir = join(frameworkDir, 'workflows');
+
+  if (!existsSync(workflowsDir)) {
+    results.errors.push('workflows/ directory not found');
+    return;
+  }
+
+  // Collect known agent names
+  const knownAgents = new Set(['orchestrator']);
+  const agentDirs = ['agents/planning', 'agents/quality', 'agents/build', 'agents/deploy'];
+  for (const dir of agentDirs) {
+    const fullDir = join(frameworkDir, dir);
+    if (!existsSync(fullDir)) continue;
+    for (const file of readdirSync(fullDir)) {
+      if (file.endsWith('.md')) {
+        knownAgents.add(basename(file, '.md'));
+      }
+    }
+  }
+
+  const workflowFiles = readdirSync(workflowsDir).filter(f => f.endsWith('.yaml'));
+  const unknownRefs = [];
+
+  for (const file of workflowFiles) {
+    const content = readFileSync(join(workflowsDir, file), 'utf-8');
+    // Look for agent references in YAML (agent: xxx or - xxx in steps)
+    const agentRefs = content.match(/agent:\s*(\S+)/g) || [];
+    for (const ref of agentRefs) {
+      const agentName = ref.replace('agent:', '').trim();
+      if (agentName && !knownAgents.has(agentName)) {
+        unknownRefs.push(`${file}: ${agentName}`);
+      }
+    }
+  }
+
+  if (unknownRefs.length === 0) {
+    results.passed++;
+    results.details.push(`Workflow-agent references: ${workflowFiles.length} workflows, all agents valid`);
+  } else {
+    results.warnings.push(`Unknown agent refs in workflows: ${unknownRefs.join('; ')}`);
+    results.passed++; // warnings don't fail
+  }
+}
+
+/**
+ * Flatten a nested object into dot-notation keys.
+ */
+function flattenKeys(obj, prefix = '') {
+  const keys = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      keys.push(...flattenKeys(value, fullKey));
+    } else {
+      keys.push(fullKey);
+    }
+  }
+  return keys;
+}
+
+/**
+ * Run all semantic lint checks.
+ * @param {string} frameworkDir - Path to the framework directory (chati.dev/)
+ * @returns {{ errors: string[], warnings: string[], details: string[], checks: number, passed: number }}
+ */
+export function semanticLint(frameworkDir) {
+  const results = { errors: [], warnings: [], details: [], checks: 0, passed: 0 };
+
+  checkEntityRegistryIntegrity(frameworkDir, results);
+  checkDomainAgentAlignment(frameworkDir, results);
+  checkWorkflowAgentRefs(frameworkDir, results);
+  checkI18nCompleteness(frameworkDir, results);
+  checkSchemaExistence(frameworkDir, results);
+  checkConstitution(frameworkDir, results);
+
+  return results;
+}
+
+/**
+ * Format results for CLI output.
+ */
+function formatResults(results) {
+  const status = results.errors.length === 0 ? 'PASS' : 'FAIL';
+  const lines = [
+    `Semantic Lint: ${status} (${results.passed}/${results.checks} checks, ${results.warnings.length} warnings, ${results.errors.length} errors)`,
+    '',
+  ];
+
+  for (const detail of results.details) {
+    lines.push(`  ✓ ${detail}`);
+  }
+
+  for (const warning of results.warnings) {
+    lines.push(`  ⚠ ${warning}`);
+  }
+
+  for (const error of results.errors) {
+    lines.push(`  ✗ ${error}`);
+  }
+
+  return lines.join('\n');
+}
+
+// CLI entry point
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const frameworkDir = join(__dirname, '..', '..', '..', 'chati.dev');
+  const results = semanticLint(frameworkDir);
+
+  console.log(formatResults(results));
+
+  if (results.errors.length > 0) {
+    process.exit(1);
+  }
+}

package/scripts/sign-manifest.js

@@ -0,0 +1,53 @@
+/**
+ * Sign the framework manifest with Ed25519.
+ * Generates manifest.json (file hashes) + manifest.sig (signature).
+ *
+ * Run: node scripts/sign-manifest.js
+ * Requires: .signing-key.pem (generated by generate-signing-key.js)
+ */
+import { sign, createPrivateKey } from 'crypto';
+import { readFileSync, writeFileSync, readdirSync, existsSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { generateManifest } from '../src/installer/manifest.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const frameworkDir = join(__dirname, '..', 'framework');
+const privateKeyPath = join(__dirname, '..', '.signing-key.pem');
+
+if (!existsSync(frameworkDir)) {
+  console.error('Framework directory not found. Run bundle-framework.js first.');
+  process.exit(1);
+}
+
+if (!existsSync(privateKeyPath)) {
+  console.warn('No signing key found at .signing-key.pem — skipping manifest signing.');
+  process.exit(0);
+}
+
+function collectFiles(dir, base = dir) {
+  let files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files = files.concat(collectFiles(full, base));
+    } else if (entry.name !== 'manifest.json' && entry.name !== 'manifest.sig') {
+      files.push(relative(base, full));
+    }
+  }
+  return files.sort();
+}
+
+const files = collectFiles(frameworkDir);
+const version = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')).version;
+const manifest = generateManifest(frameworkDir, files, version);
+
+const manifestJson = JSON.stringify(manifest, Object.keys(manifest).sort(), 2);
+
+const privateKey = createPrivateKey(readFileSync(privateKeyPath));
+const signature = sign(null, Buffer.from(manifestJson), privateKey);
+
+writeFileSync(join(frameworkDir, 'manifest.json'), manifestJson + '\n');
+writeFileSync(join(frameworkDir, 'manifest.sig'), signature.toString('base64'));
+
+console.log(`Signed manifest: ${Object.keys(manifest.files).length} files, v${version}`);

package/scripts/validate-agents.js

@@ -19,7 +19,7 @@ import yaml from 'js-yaml';
  * Expected agents organized by category.
  */
 export const EXPECTED_AGENTS = {
-  clarity: ['greenfield-wu', 'brownfield-wu', 'brief', 'detail', 'architect', 'ux', 'phases', 'tasks'],
+  planning: ['greenfield-wu', 'brownfield-wu', 'brief', 'detail', 'architect', 'ux', 'phases', 'tasks'],
   quality: ['qa-planning', 'qa-implementation'],
   build: ['dev'],
   deploy: ['devops'],

package/scripts/validate-package.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+/**
+ * Package Completeness Validator
+ *
+ * Validates that the npm package has all required files before publishing.
+ * Run as part of prepublishOnly (after bundle, before sign-manifest).
+ *
+ * Exports:
+ *   validatePackage(packageRoot) → { errors, warnings, checks, passed }
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Expected directories in framework/ (must match bundle-framework.js)
+ */
+const EXPECTED_BUNDLE_DIRS = [
+  'orchestrator',
+  'agents/planning', 'agents/quality', 'agents/build', 'agents/deploy',
+  'templates', 'workflows', 'quality-gates',
+  'schemas', 'frameworks', 'intelligence', 'patterns',
+  'hooks', 'domains',
+  'i18n', 'migrations', 'data',
+  'tasks', 'context',
+];
+
+const EXPECTED_ROOT_FILES = ['constitution.md', 'config.yaml'];
+
+const SENSITIVE_FILES = ['.signing-key.pem', '.env', '.env.local', '.env.production'];
+
+/**
+ * Validate that framework/ directory exists.
+ */
+function checkFrameworkExists(packageRoot, results) {
+  results.checks++;
+  const frameworkDir = join(packageRoot, 'framework');
+  if (existsSync(frameworkDir)) {
+    results.passed++;
+  } else {
+    results.errors.push('framework/ directory not found. Run `npm run bundle` first.');
+  }
+}
+
+/**
+ * Validate all expected bundle directories exist.
+ */
+function checkBundledDirs(packageRoot, results) {
+  results.checks++;
+  const frameworkDir = join(packageRoot, 'framework');
+  if (!existsSync(frameworkDir)) return;
+
+  const missing = [];
+  for (const dir of EXPECTED_BUNDLE_DIRS) {
+    if (!existsSync(join(frameworkDir, dir))) {
+      missing.push(dir);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Missing framework directories: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Validate root framework files exist.
+ */
+function checkRootFiles(packageRoot, results) {
+  results.checks++;
+  const frameworkDir = join(packageRoot, 'framework');
+  if (!existsSync(frameworkDir)) return;
+
+  const missing = [];
+  for (const file of EXPECTED_ROOT_FILES) {
+    if (!existsSync(join(frameworkDir, file))) {
+      missing.push(file);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Missing framework root files: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Check that no sensitive files leaked into the bundle.
+ */
+function checkNoSensitiveFiles(packageRoot, results) {
+  results.checks++;
+  const found = [];
+
+  // Only check inside publishable directories (bin/, src/, assets/, framework/, scripts/)
+  // Root-level files like .signing-key.pem are excluded by package.json "files" field
+  const publishableDirs = ['framework', 'src', 'scripts', 'bin', 'assets'];
+  for (const file of SENSITIVE_FILES) {
+    for (const dir of publishableDirs) {
+      if (existsSync(join(packageRoot, dir, file))) {
+        found.push(`${dir}/${file}`);
+      }
+    }
+  }
+
+  if (found.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Sensitive files found in package: ${found.join(', ')}`);
+  }
+}
+
+/**
+ * Validate that all package.json exports resolve to existing files.
+ */
+function checkExportsResolve(packageRoot, results) {
+  results.checks++;
+  const pkgPath = join(packageRoot, 'package.json');
+  if (!existsSync(pkgPath)) return;
+
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const exports = pkg.exports || {};
+  const missing = [];
+
+  for (const [key, value] of Object.entries(exports)) {
+    const filePath = join(packageRoot, value);
+    if (!existsSync(filePath)) {
+      missing.push(`${key} → ${value}`);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Unresolved exports: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Validate that bin entry exists.
+ */
+function checkBinExists(packageRoot, results) {
+  results.checks++;
+  const pkgPath = join(packageRoot, 'package.json');
+  if (!existsSync(pkgPath)) return;
+
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const bin = pkg.bin || {};
+  const missing = [];
+
+  for (const [name, path] of Object.entries(bin)) {
+    if (!existsSync(join(packageRoot, path))) {
+      missing.push(`${name} → ${path}`);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Missing bin entries: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Compare entity count in registry vs actual files in framework/.
+ */
+function checkEntityCount(packageRoot, results) {
+  results.checks++;
+  const registryPath = join(packageRoot, 'framework', 'data', 'entity-registry.yaml');
+  if (!existsSync(registryPath)) {
+    results.warnings.push('Entity registry not found in framework/data/ — skipping count check.');
+    results.passed++;
+    return;
+  }
+
+  // Count files in framework/ recursively (excluding manifest.json, manifest.sig)
+  let fileCount = 0;
+  function countFiles(dir) {
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          countFiles(join(dir, entry.name));
+        } else if (entry.name !== 'manifest.json' && entry.name !== 'manifest.sig') {
+          fileCount++;
+        }
+      }
+    } catch { /* skip unreadable dirs */ }
+  }
+
+  countFiles(join(packageRoot, 'framework'));
+
+  if (fileCount > 0) {
+    results.passed++;
+  } else {
+    results.errors.push('Framework directory is empty (0 files).');
+  }
+}
+
+/**
+ * Validate the npm package completeness.
+ * @param {string} packageRoot - Root of the package (packages/chati-dev/)
+ * @returns {{ errors: string[], warnings: string[], checks: number, passed: number }}
+ */
+export function validatePackage(packageRoot) {
+  const results = { errors: [], warnings: [], checks: 0, passed: 0 };
+
+  checkFrameworkExists(packageRoot, results);
+  checkBundledDirs(packageRoot, results);
+  checkRootFiles(packageRoot, results);
+  checkNoSensitiveFiles(packageRoot, results);
+  checkExportsResolve(packageRoot, results);
+  checkBinExists(packageRoot, results);
+  checkEntityCount(packageRoot, results);
+
+  return results;
+}
+
+/**
+ * Format results for CLI output.
+ */
+function formatResults(results) {
+  const status = results.errors.length === 0 ? 'PASS' : 'FAIL';
+  const lines = [
+    `Package Validation: ${status} (${results.passed}/${results.checks} checks passed)`,
+  ];
+
+  if (results.errors.length > 0) {
+    lines.push('');
+    lines.push('Errors:');
+    results.errors.forEach(e => lines.push(`  ✗ ${e}`));
+  }
+
+  if (results.warnings.length > 0) {
+    lines.push('');
+    lines.push('Warnings:');
+    results.warnings.forEach(w => lines.push(`  ⚠ ${w}`));
+  }
+
+  return lines.join('\n');
+}
+
+// CLI entry point
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const packageRoot = join(__dirname, '..');
+  const results = validatePackage(packageRoot);
+
+  console.log(formatResults(results));
+
+  if (results.errors.length > 0) {
+    process.exit(1);
+  }
+}

package/scripts/validate-tasks.js

@@ -24,7 +24,7 @@ const REQUIRED_FIELDS = ['id', 'agent'];
 /**
  * Valid phase values.
  */
-const VALID_PHASES = ['clarity', 'build', 'deploy', 'validate', 'quality'];
+const VALID_PHASES = ['planning', 'build', 'deploy', 'validate', 'quality'];
 
 // ---------------------------------------------------------------------------
 // Internal Helpers

package/src/autonomy/autonomous-gate.js

@@ -16,8 +16,8 @@ export const GATE_RESULTS = {
 
 // Minimum passing scores per agent (conservative: 90 default)
 const GATE_THRESHOLDS = {
-  'qa-planning': 95,        // Highest — gates clarity→build transition
-  'qa-implementation': 90,  // Gates build→deploy transition
+  'qa-planning': 95,        // Highest — gates planning→build transition
+  'qa-implementation': 95,  // Gates build→deploy transition
   'brief': 90,              // Requirements are critical
   'detail': 90,
   'architect': 90,