chati-dev 1.2.1 → 1.3.0

package/src/intelligence/memory-manager.js

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { join, relative } from 'path';
+
+const MEMORIES_DIR = '.chati/memories';
+
+/**
+ * List memories with optional filters
+ */
+export function listMemories(targetDir, options = {}) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) return [];
+
+  const memories = [];
+  walkMemories(memoriesPath, (filePath) => {
+    const meta = parseMemoryFrontmatter(filePath);
+    if (!meta) return;
+
+    if (options.agent && meta.agent !== options.agent) return;
+    if (options.sector && meta.sector !== options.sector) return;
+    if (options.tier && meta.tier !== options.tier) return;
+
+    memories.push({
+      ...meta,
+      path: relative(memoriesPath, filePath),
+    });
+  });
+
+  return memories;
+}
+
+/**
+ * Search memories by query (matches tags and content)
+ */
+export function searchMemories(targetDir, query) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) return [];
+
+  const queryLower = query.toLowerCase();
+  const results = [];
+
+  walkMemories(memoriesPath, (filePath) => {
+    const content = readFileSync(filePath, 'utf-8');
+    const meta = parseMemoryFrontmatter(filePath);
+    if (!meta) return;
+
+    const tagMatch = meta.tags && meta.tags.some(t => t.toLowerCase().includes(queryLower));
+    const contentMatch = content.toLowerCase().includes(queryLower);
+
+    if (tagMatch || contentMatch) {
+      results.push({
+        ...meta,
+        path: relative(memoriesPath, filePath),
+        matchType: tagMatch ? 'tag' : 'content',
+      });
+    }
+  });
+
+  return results;
+}
+
+/**
+ * Clean expired or cold memories
+ */
+export function cleanMemories(targetDir, options = {}) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) return { cleaned: 0, skipped: 0 };
+
+  let cleaned = 0;
+  let skipped = 0;
+
+  walkMemories(memoriesPath, (filePath) => {
+    const meta = parseMemoryFrontmatter(filePath);
+    if (!meta) { skipped++; return; }
+
+    // Clean session-tier memories (they should be cleaned on new session start)
+    const isSessionTier = filePath.includes('/session/');
+
+    // Clean expired memories
+    const isExpired = meta.expires_at && new Date(meta.expires_at) < new Date();
+
+    if (isSessionTier || isExpired) {
+      if (!options.dryRun) {
+        unlinkSync(filePath);
+      }
+      cleaned++;
+    } else {
+      skipped++;
+    }
+  });
+
+  return { cleaned, skipped, dryRun: !!options.dryRun };
+}
+
+/**
+ * Get memory statistics
+ */
+export function getMemoryStats(targetDir) {
+  const memoriesPath = join(targetDir, MEMORIES_DIR);
+  if (!existsSync(memoriesPath)) {
+    return { total: 0, byAgent: {}, bySector: {}, byTier: {}, diskUsage: 0 };
+  }
+
+  const stats = {
+    total: 0,
+    byAgent: {},
+    bySector: {},
+    byTier: { hot: 0, warm: 0, cold: 0 },
+    diskUsage: 0,
+  };
+
+  walkMemories(memoriesPath, (filePath) => {
+    const meta = parseMemoryFrontmatter(filePath);
+    const fileStats = statSync(filePath);
+    stats.diskUsage += fileStats.size;
+
+    if (!meta) return;
+    stats.total++;
+
+    if (meta.agent) {
+      stats.byAgent[meta.agent] = (stats.byAgent[meta.agent] || 0) + 1;
+    }
+    if (meta.sector) {
+      stats.bySector[meta.sector] = (stats.bySector[meta.sector] || 0) + 1;
+    }
+    if (meta.tier && stats.byTier[meta.tier] !== undefined) {
+      stats.byTier[meta.tier]++;
+    }
+  });
+
+  return stats;
+}
+
+/**
+ * Walk memory files recursively
+ */
+export function walkMemories(dir, callback) {
+  if (!existsSync(dir)) return;
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkMemories(fullPath, callback);
+    } else if (entry.name.endsWith('.md')) {
+      callback(fullPath);
+    }
+  }
+}
+
+/**
+ * Parse YAML frontmatter from a memory file
+ */
+export function parseMemoryFrontmatter(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+
+    // Simple YAML parsing for frontmatter (no dependency on js-yaml)
+    const lines = fmMatch[1].split('\n');
+    const meta = {};
+    for (const line of lines) {
+      const colonIdx = line.indexOf(':');
+      if (colonIdx === -1) continue;
+      const key = line.slice(0, colonIdx).trim();
+      let value = line.slice(colonIdx + 1).trim();
+
+      // Handle arrays [a, b, c]
+      if (value.startsWith('[') && value.endsWith(']')) {
+        value = value.slice(1, -1).split(',').map(s => s.trim());
+      }
+      // Handle numbers
+      else if (!isNaN(value) && value !== '') {
+        value = parseFloat(value);
+      }
+      // Handle quoted strings
+      else if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      meta[key] = value;
+    }
+
+    return meta;
+  } catch {
+    return null;
+  }
+}

package/src/intelligence/registry-manager.js

@@ -0,0 +1,202 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+const REGISTRY_PATH = 'chati.dev/data/entity-registry.yaml';
+
+/**
+ * Check registry integrity against filesystem
+ */
+export function checkRegistry(targetDir) {
+  const registryPath = join(targetDir, REGISTRY_PATH);
+  if (!existsSync(registryPath)) {
+    return { valid: false, error: 'Entity registry not found', missing: [], orphaned: [] };
+  }
+
+  const registry = loadRegistry(registryPath);
+  if (!registry) {
+    return { valid: false, error: 'Failed to parse entity registry', missing: [], orphaned: [] };
+  }
+
+  const missing = [];
+  const found = [];
+
+  // Check each registered entity exists on disk
+  const entities = flattenEntities(registry.entities);
+  for (const entity of entities) {
+    const filePath = join(targetDir, entity.path);
+    if (existsSync(filePath)) {
+      found.push(entity);
+    } else {
+      missing.push(entity);
+    }
+  }
+
+  return {
+    valid: missing.length === 0,
+    totalEntities: entities.length,
+    found: found.length,
+    missing,
+  };
+}
+
+/**
+ * Get registry statistics
+ */
+export function getRegistryStats(targetDir) {
+  const registryPath = join(targetDir, REGISTRY_PATH);
+  if (!existsSync(registryPath)) {
+    return { exists: false, totalEntities: 0, byType: {} };
+  }
+
+  const registry = loadRegistry(registryPath);
+  if (!registry) {
+    return { exists: true, totalEntities: 0, byType: {}, error: 'Parse error' };
+  }
+
+  const entities = flattenEntities(registry.entities);
+  const byType = {};
+  for (const entity of entities) {
+    const type = entity.type || 'unknown';
+    byType[type] = (byType[type] || 0) + 1;
+  }
+
+  return {
+    exists: true,
+    version: registry.metadata?.version || 'unknown',
+    totalEntities: entities.length,
+    declaredCount: registry.metadata?.entity_count || 0,
+    countMatch: entities.length === (registry.metadata?.entity_count || 0),
+    byType,
+  };
+}
+
+/**
+ * Validate all entities exist on disk
+ */
+export function validateEntities(targetDir) {
+  const result = checkRegistry(targetDir);
+  return {
+    valid: result.valid,
+    total: result.totalEntities || 0,
+    found: result.found || 0,
+    missing: (result.missing || []).map(e => e.path),
+  };
+}
+
+/**
+ * Run comprehensive health check
+ */
+export function runHealthCheck(targetDir) {
+  const checks = {
+    registry: { pass: false, details: '' },
+    schemas: { pass: false, details: '' },
+    constitution: { pass: false, details: '' },
+    agents: { pass: false, details: '' },
+    entities: { pass: false, details: '' },
+    overall: 'UNHEALTHY',
+  };
+
+  // 1. Registry check
+  const registryStats = getRegistryStats(targetDir);
+  if (registryStats.exists && registryStats.totalEntities > 0) {
+    checks.registry.pass = true;
+    checks.registry.details = `${registryStats.totalEntities} entities registered (v${registryStats.version})`;
+  } else {
+    checks.registry.details = registryStats.exists ? 'Registry empty or invalid' : 'Registry not found';
+  }
+
+  // 2. Schema validation
+  const schemaFiles = [
+    'session.schema.json', 'config.schema.json', 'task.schema.json',
+    'context.schema.json', 'memory.schema.json',
+  ];
+  let validSchemas = 0;
+  for (const file of schemaFiles) {
+    const schemaPath = join(targetDir, 'chati.dev', 'schemas', file);
+    if (existsSync(schemaPath)) {
+      try {
+        JSON.parse(readFileSync(schemaPath, 'utf-8'));
+        validSchemas++;
+      } catch {
+        // Invalid JSON
+      }
+    }
+  }
+  checks.schemas.pass = validSchemas === schemaFiles.length;
+  checks.schemas.details = `${validSchemas}/${schemaFiles.length} valid`;
+
+  // 3. Constitution check
+  const constitutionPath = join(targetDir, 'chati.dev', 'constitution.md');
+  if (existsSync(constitutionPath)) {
+    const content = readFileSync(constitutionPath, 'utf-8');
+    const articleCount = (content.match(/^## Article/gm) || []).length;
+    checks.constitution.pass = articleCount >= 15;
+    checks.constitution.details = `${articleCount}/15 articles`;
+  } else {
+    checks.constitution.details = 'Not found';
+  }
+
+  // 4. Agent check
+  const agentPaths = [
+    'orchestrator/chati.md',
+    'agents/clarity/greenfield-wu.md', 'agents/clarity/brownfield-wu.md',
+    'agents/clarity/brief.md', 'agents/clarity/detail.md',
+    'agents/clarity/architect.md', 'agents/clarity/ux.md',
+    'agents/clarity/phases.md', 'agents/clarity/tasks.md',
+    'agents/quality/qa-planning.md', 'agents/quality/qa-implementation.md',
+    'agents/build/dev.md', 'agents/deploy/devops.md',
+  ];
+  let foundAgents = 0;
+  for (const p of agentPaths) {
+    if (existsSync(join(targetDir, 'chati.dev', p))) foundAgents++;
+  }
+  checks.agents.pass = foundAgents === 13;
+  checks.agents.details = `${foundAgents}/13 present`;
+
+  // 5. Entity validation (registry vs filesystem)
+  const entityResult = validateEntities(targetDir);
+  checks.entities.pass = entityResult.valid;
+  checks.entities.details = `${entityResult.found}/${entityResult.total} present`;
+
+  // Overall
+  const passCount = Object.values(checks).filter(c => c && c.pass).length;
+  const totalChecks = 5;
+  checks.overall = passCount === totalChecks ? 'HEALTHY' : passCount >= 3 ? 'DEGRADED' : 'UNHEALTHY';
+  checks.passCount = passCount;
+  checks.totalChecks = totalChecks;
+
+  return checks;
+}
+
+/**
+ * Load and parse registry YAML
+ */
+function loadRegistry(registryPath) {
+  try {
+    const content = readFileSync(registryPath, 'utf-8');
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Flatten nested entity categories into flat array
+ */
+function flattenEntities(entities) {
+  if (!entities) return [];
+  const flat = [];
+
+  for (const [, items] of Object.entries(entities)) {
+    if (typeof items === 'object' && items !== null) {
+      for (const [name, entity] of Object.entries(items)) {
+        if (entity && entity.path) {
+          flat.push({ name, ...entity });
+        }
+      }
+    }
+  }
+
+  return flat;
+}

package/src/upgrade/backup.js

@@ -28,6 +28,8 @@ export function createBackup(targetDir, currentVersion) {
     'i18n',
     'patterns',
     'migrations',
+    'intelligence',
+    'data',
   ];
 
   const filesToBackup = [

package/src/upgrade/migrator.js

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
 import yaml from 'js-yaml';
 import semver from 'semver';

package/src/utils/logger.js

@@ -26,7 +26,7 @@ export function logBanner(logoText, version) {
     console.log(brand(line));
   }
   console.log(brand(`chati.dev v${version}`));
-  console.log(dim('AI-Powered Multi-Agent Development Framework'));
+  console.log(dim('AI-Powered Multi-Agent Orchestration System'));
   console.log(dim('═'.repeat(55)));
   console.log();
 }

package/src/wizard/i18n.js

@@ -26,15 +26,15 @@ const FALLBACK_EN = {
     agents_count: '13 agent definitions (CLARITY, BUILD, DEPLOY phases)',
     workflows_count: '5 workflow blueprints',
     templates_count: '5 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate)',
-    constitution: 'Constitution (10 Articles + Preamble)',
+    constitution: 'Constitution (15 Articles + Preamble)',
     session_mgmt: 'Session management system',
     quality_gates: 'Quality gates (4-tier validation)',
     proceed: 'Proceed with installation?',
     installing: 'Installing chati.dev...',
     created_chati: 'Created .chati/ session directory',
-    created_framework: 'Created chati.dev/ framework directory (agents, templates, workflows)',
+    created_framework: 'Created chati.dev/ system directory (agents, templates, workflows)',
     created_commands: 'Created .claude/commands/ (thin router)',
-    installed_constitution: 'Installed Constitution (Articles I-X)',
+    installed_constitution: 'Installed Constitution (Articles I-XV)',
     created_session: 'Created session.yaml schema',
     created_claude_md: 'Created CLAUDE.md',
     configured_mcps: 'Configured MCPs:',
@@ -42,7 +42,12 @@ const FALLBACK_EN = {
     agents_valid: 'All 13 agents implement 8 protocols',
     handoff_ok: 'Handoff protocol: OK',
     validation_ok: 'Self-validation criteria: OK',
-    constitution_ok: 'Constitution: 10 articles verified',
+    constitution_ok: 'Constitution: 15 articles verified',
+    created_memories: 'Created .chati/memories/ (Memory Layer)',
+    installed_intelligence: 'Installed Intelligence Layer (Context Engine, Memory, Registry)',
+    intelligence_valid: 'Intelligence: 6 spec files verified',
+    registry_valid: 'Entity Registry: valid',
+    memories_valid: 'Memory directory tree: valid',
     session_ok: 'Session schema: valid',
     success: 'chati.dev installed successfully!',
     quick_start_title: 'Quick Start',

package/src/wizard/index.js

@@ -69,6 +69,8 @@ export async function runWizard(targetDir, options = {}) {
     showStep(t('installer.installed_constitution'));
     showStep(t('installer.created_session'));
     showStep(t('installer.created_claude_md'));
+    showStep(t('installer.created_memories'));
+    showStep(t('installer.installed_intelligence'));
 
     if (selectedMCPs.length > 0) {
       showStep(`${t('installer.configured_mcps')} ${selectedMCPs.join(', ')}`);
@@ -86,6 +88,9 @@ export async function runWizard(targetDir, options = {}) {
     showValidation(t('installer.handoff_ok'));
     showValidation(t('installer.validation_ok'));
     showValidation(t('installer.constitution_ok'));
+    showValidation(t('installer.intelligence_valid'));
+    showValidation(t('installer.registry_valid'));
+    showValidation(t('installer.memories_valid'));
     showValidation(t('installer.session_ok'));
 
     console.log();