chati-dev 4.3.0 → 4.4.0

package/src/decision/registry-updater.js

@@ -1,339 +0,0 @@
-/**
- * Registry Updater - Auto-updates entity-registry.yaml
- * Scans project for new/changed/removed entities
- *
- * @module decision/registry-updater
- */
-
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, basename, relative } from 'path';
-import yaml from 'js-yaml';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-
-/**
- * Build KNOWN_DIRS using resolveFrameworkDir so paths are correct
- * for both chati.dev/ and .chati.dev/ installations.
- * @param {string} projectDir
- * @returns {{ path: string, type: string }[]}
- */
-function buildKnownDirs(projectDir) {
-  const fw = resolveFrameworkDir(projectDir);
-  return [
-    { path: `${fw}/agents`, type: 'agent' },
-    { path: `${fw}/tasks`, type: 'task' },
-    { path: `${fw}/schemas`, type: 'schema' },
-    { path: `${fw}/domains`, type: 'domain' },
-    { path: `${fw}/hooks`, type: 'hook' },
-    { path: `${fw}/workflows`, type: 'workflow' },
-    { path: `${fw}/templates`, type: 'template' },
-  ];
-}
-
-/**
- * Scan project for new/changed files and update registry.
- * @param {string} projectDir
- * @param {object} [options] - { dryRun: boolean }
- * @returns {{ added: string[], removed: string[], updated: string[], unchanged: number }}
- */
-export function updateRegistry(projectDir, options = {}) {
-  const { dryRun = false } = options;
-  const registryPath = join(projectDir, resolveFrameworkDir(projectDir), 'entity-registry.yaml');
-
-  let registry = {
-    metadata: {
-      version: '1.0',
-      entity_count: 0,
-      last_updated: new Date().toISOString()
-    },
-    entities: {}
-  };
-
-  // Load existing registry
-  if (existsSync(registryPath)) {
-    registry = yaml.load(readFileSync(registryPath, 'utf8'));
-  }
-
-  const existingPaths = new Set();
-  Object.values(registry.entities || {}).forEach(typeEntities => {
-    if (Array.isArray(typeEntities)) {
-      typeEntities.forEach(entity => {
-        if (entity.path) {
-          existingPaths.add(entity.path);
-        }
-      });
-    }
-  });
-
-  // Detect new entities
-  const newEntities = detectNewEntities(projectDir);
-  const newPaths = new Set(newEntities.map(e => e.path));
-
-  // Detect removed entities
-  const removedEntities = detectRemovedEntities(projectDir);
-  const removedPaths = new Set(removedEntities.map(e => e.path));
-
-  // Track changes
-  const changes = {
-    added: [],
-    removed: [],
-    updated: [],
-    unchanged: 0
-  };
-
-  // Add new entities
-  newEntities.forEach(entity => {
-    if (!existingPaths.has(entity.path)) {
-      changes.added.push(entity.path);
-
-      if (!dryRun) {
-        const type = entity.type;
-        if (!registry.entities[type]) {
-          registry.entities[type] = [];
-        }
-        registry.entities[type].push(entity);
-      }
-    }
-  });
-
-  // Remove deleted entities
-  removedEntities.forEach(entity => {
-    if (existingPaths.has(entity.path)) {
-      changes.removed.push(entity.path);
-
-      if (!dryRun) {
-        const type = entity.type;
-        if (registry.entities[type]) {
-          registry.entities[type] = registry.entities[type].filter(
-            e => e.path !== entity.path
-          );
-        }
-      }
-    }
-  });
-
-  // Check for updates (files modified after last registry update)
-  existingPaths.forEach(path => {
-    if (!removedPaths.has(path) && !newPaths.has(path)) {
-      const fullPath = join(projectDir, path);
-      if (existsSync(fullPath)) {
-        const stats = statSync(fullPath);
-        const lastUpdated = registry.metadata?.last_updated
-          ? new Date(registry.metadata.last_updated)
-          : new Date(0);
-
-        if (stats.mtime > lastUpdated) {
-          changes.updated.push(path);
-
-          if (!dryRun) {
-            // Regenerate metadata
-            const newMeta = generateEntityMeta(projectDir, path);
-            Object.entries(registry.entities).forEach(([type, entities]) => {
-              const index = entities.findIndex(e => e.path === path);
-              if (index !== -1) {
-                registry.entities[type][index] = { ...newMeta, path };
-              }
-            });
-          }
-        } else {
-          changes.unchanged++;
-        }
-      }
-    }
-  });
-
-  // Update metadata
-  if (!dryRun) {
-    let totalCount = 0;
-    Object.values(registry.entities).forEach(typeEntities => {
-      if (Array.isArray(typeEntities)) {
-        totalCount += typeEntities.length;
-      }
-    });
-
-    registry.metadata.entity_count = totalCount;
-    registry.metadata.last_updated = new Date().toISOString();
-
-    writeFileSync(registryPath, yaml.dump(registry), 'utf8');
-  }
-
-  return changes;
-}
-
-/**
- * Detect new entities that aren't in the registry.
- * Scans known directories (chati.dev/agents, chati.dev/tasks, etc).
- * @param {string} projectDir
- * @returns {object[]} New entity candidates
- */
-export function detectNewEntities(projectDir) {
-  const registryPath = join(projectDir, resolveFrameworkDir(projectDir), 'entity-registry.yaml');
-  const existingPaths = new Set();
-
-  if (existsSync(registryPath)) {
-    const registry = yaml.load(readFileSync(registryPath, 'utf8'));
-    Object.values(registry.entities || {}).forEach(typeEntities => {
-      if (Array.isArray(typeEntities)) {
-        typeEntities.forEach(entity => {
-          if (entity.path) {
-            existingPaths.add(entity.path);
-          }
-        });
-      }
-    });
-  }
-
-  const newEntities = [];
-
-  buildKnownDirs(projectDir).forEach(({ path: dirPath, type }) => {
-    const fullPath = join(projectDir, dirPath);
-    if (!existsSync(fullPath)) {
-      return;
-    }
-
-    const files = scanDirectory(fullPath);
-    files.forEach(file => {
-      const relativePath = relative(projectDir, file);
-      if (!existingPaths.has(relativePath)) {
-        const meta = generateEntityMeta(projectDir, relativePath);
-        newEntities.push({
-          ...meta,
-          path: relativePath,
-          type
-        });
-      }
-    });
-  });
-
-  return newEntities;
-}
-
-/**
- * Detect removed entities (in registry but not on disk).
- * @param {string} projectDir
- * @returns {object[]} Removed entity candidates
- */
-export function detectRemovedEntities(projectDir) {
-  const registryPath = join(projectDir, resolveFrameworkDir(projectDir), 'entity-registry.yaml');
-  if (!existsSync(registryPath)) {
-    return [];
-  }
-
-  const registry = yaml.load(readFileSync(registryPath, 'utf8'));
-  const removedEntities = [];
-
-  Object.entries(registry.entities || {}).forEach(([type, entities]) => {
-    if (Array.isArray(entities)) {
-      entities.forEach(entity => {
-        if (entity.path) {
-          const fullPath = join(projectDir, entity.path);
-          if (!existsSync(fullPath)) {
-            removedEntities.push({ ...entity, type });
-          }
-        }
-      });
-    }
-  });
-
-  return removedEntities;
-}
-
-/**
- * Generate entity metadata from file.
- * Extracts type, purpose, keywords from filename and content.
- * @param {string} projectDir
- * @param {string} filePath
- * @returns {object} Entity metadata
- */
-export function generateEntityMeta(projectDir, filePath) {
-  const fullPath = join(projectDir, filePath);
-  const fileName = basename(filePath, '.md');
-
-  const meta = {
-    name: fileName,
-    keywords: [],
-    purpose: ''
-  };
-
-  // Extract keywords from filename
-  const nameWords = fileName
-    .replace(/[._-]/g, ' ')
-    .toLowerCase()
-    .split(/\W+/)
-    .filter(w => w.length > 3);
-  meta.keywords.push(...nameWords);
-
-  // Try to extract purpose from file content
-  if (existsSync(fullPath)) {
-    try {
-      const content = readFileSync(fullPath, 'utf8');
-      const lines = content.split('\n').slice(0, 20); // First 20 lines
-
-      // Look for common purpose patterns
-      for (const line of lines) {
-        const purposeMatch = line.match(/^#+\s*(.+)$/); // Markdown heading
-        if (purposeMatch) {
-          meta.purpose = purposeMatch[1].trim();
-          break;
-        }
-
-        const descMatch = line.match(/^(?:description|purpose|summary):\s*(.+)$/i);
-        if (descMatch) {
-          meta.purpose = descMatch[1].trim();
-          break;
-        }
-      }
-
-      // Extract additional keywords from content
-      const contentWords = content
-        .toLowerCase()
-        .split(/\W+/)
-        .filter(w => w.length > 5); // Longer words only
-      const wordFreq = new Map();
-      contentWords.forEach(w => {
-        wordFreq.set(w, (wordFreq.get(w) || 0) + 1);
-      });
-
-      // Add top 5 frequent words as keywords
-      const topWords = [...wordFreq.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5)
-        .map(([word]) => word);
-      meta.keywords.push(...topWords);
-    } catch { /* expected: operation may fail gracefully */
-      // Ignore read errors
-    }
-  }
-
-  // Remove duplicates
-  meta.keywords = [...new Set(meta.keywords)];
-
-  return meta;
-}
-
-/**
- * Recursively scan directory for files.
- * @private
- * @param {string} dirPath
- * @returns {string[]} Array of file paths
- */
-function scanDirectory(dirPath) {
-  const files = [];
-
-  try {
-    const entries = readdirSync(dirPath);
-    entries.forEach(entry => {
-      const fullPath = join(dirPath, entry);
-      const stats = statSync(fullPath);
-
-      if (stats.isDirectory()) {
-        files.push(...scanDirectory(fullPath));
-      } else if (stats.isFile() && entry.endsWith('.md')) {
-        files.push(fullPath);
-      }
-    });
-  } catch { /* expected: operation may fail gracefully */
-    // Ignore read errors
-  }
-
-  return files;
-}

package/src/extensions/loader.js

@@ -1,145 +0,0 @@
-/**
- * @fileoverview Extension loader for chati.dev.
- *
- * Discovers and loads project-level extensions from
- * `chati.dev/extensions/*.js`, validates them, and registers
- * them in the extension registry.
- *
- * Constitution Article XIV — Framework Registry Governance.
- */
-
-import { existsSync, readdirSync } from 'fs';
-import { join, extname, basename } from 'path';
-import { registerExtension, EXTENSION_POINTS } from './registry.js';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-
-/** Required fields in an extension module's default export. */
-const REQUIRED_FIELDS = ['name', 'point', 'handler'];
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Validate an extension object has the required shape.
- *
- * @param {object} ext - Extension object to validate
- * @returns {{ valid: boolean, errors: string[] }}
- */
-export function validateExtension(ext) {
-  const errors = [];
-
-  if (!ext || typeof ext !== 'object') {
-    errors.push('Extension must be a non-null object');
-    return { valid: false, errors };
-  }
-
-  for (const field of REQUIRED_FIELDS) {
-    if (ext[field] === undefined || ext[field] === null) {
-      errors.push(`Missing required field: "${field}"`);
-    }
-  }
-
-  if (ext.name !== undefined && typeof ext.name !== 'string') {
-    errors.push('name must be a string');
-  }
-
-  if (ext.point !== undefined) {
-    const validPoints = Object.values(EXTENSION_POINTS);
-    if (!validPoints.includes(ext.point)) {
-      errors.push(`Invalid extension point: "${ext.point}". Valid: ${validPoints.join(', ')}`);
-    }
-  }
-
-  if (ext.handler !== undefined && typeof ext.handler !== 'function') {
-    errors.push('handler must be a function');
-  }
-
-  if (ext.priority !== undefined && typeof ext.priority !== 'number') {
-    errors.push('priority must be a number');
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Discover extension files in the project extensions directory.
- *
- * @param {string} projectDir - Project root directory
- * @returns {{ files: string[], dir: string }}
- */
-export function discoverExtensions(projectDir) {
-  if (!projectDir) {
-    return { files: [], dir: '' };
-  }
-
-  const extDir = join(projectDir, resolveFrameworkDir(projectDir), 'extensions');
-
-  if (!existsSync(extDir)) {
-    return { files: [], dir: extDir };
-  }
-
-  try {
-    const entries = readdirSync(extDir);
-    const jsFiles = entries
-      .filter(f => extname(f) === '.js')
-      .map(f => join(extDir, f));
-
-    return { files: jsFiles, dir: extDir };
-  } catch { /* expected: directory may not exist */
-    return { files: [], dir: extDir };
-  }
-}
-
-/**
- * Load and register all extensions from a project directory.
- *
- * @param {string} projectDir - Project root directory
- * @returns {Promise<{ loaded: number, failed: number, errors: Array<{ file: string, error: string }> }>}
- */
-export async function loadProjectExtensions(projectDir) {
-  const { files } = discoverExtensions(projectDir);
-  let loaded = 0;
-  let failed = 0;
-  const errors = [];
-
-  for (const filePath of files) {
-    try {
-      const mod = await import(filePath);
-      const ext = mod.default || mod;
-
-      const validation = validateExtension(ext);
-      if (!validation.valid) {
-        failed++;
-        errors.push({
-          file: basename(filePath),
-          error: validation.errors.join('; '),
-        });
-        continue;
-      }
-
-      const result = registerExtension(ext.point, ext.handler, {
-        name: ext.name,
-        priority: ext.priority || 0,
-      });
-
-      if (result.registered) {
-        loaded++;
-      } else {
-        failed++;
-        errors.push({
-          file: basename(filePath),
-          error: result.error || 'Registration failed',
-        });
-      }
-    } catch (err) {
-      failed++;
-      errors.push({
-        file: basename(filePath),
-        error: err.message,
-      });
-    }
-  }
-
-  return { loaded, failed, errors };
-}

package/src/extensions/registry.js

@@ -1,134 +0,0 @@
-/**
- * @fileoverview Extension point registry for chati.dev.
- *
- * Provides a mechanism for registering, retrieving, and
- * executing extension handlers at defined extension points.
- *
- * Constitution Article XIV — Framework Registry Governance.
- */
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/** Available extension points in the pipeline lifecycle. */
-export const EXTENSION_POINTS = {
-  PRE_AGENT: 'pre_agent',
-  POST_AGENT: 'post_agent',
-  PRE_BUILD: 'pre_build',
-  POST_BUILD: 'post_build',
-  HEALTH_CHECK: 'health_check',
-  CUSTOM_GATE: 'custom_gate',
-};
-
-// ---------------------------------------------------------------------------
-// Internal State
-// ---------------------------------------------------------------------------
-
-/** @type {Map<string, Array<{ handler: Function, name: string, priority: number }>>} */
-const _registry = new Map();
-
-// Initialize registry with empty arrays for each point
-for (const point of Object.values(EXTENSION_POINTS)) {
-  _registry.set(point, []);
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Register an extension handler at a specific point.
- *
- * @param {string} point - Extension point (from EXTENSION_POINTS)
- * @param {Function} handler - Handler function
- * @param {{ name?: string, priority?: number }} [options={}]
- * @returns {{ registered: boolean, error?: string }}
- */
-export function registerExtension(point, handler, options = {}) {
-  if (!Object.values(EXTENSION_POINTS).includes(point)) {
-    return { registered: false, error: `Unknown extension point: ${point}` };
-  }
-
-  if (typeof handler !== 'function') {
-    return { registered: false, error: 'Handler must be a function' };
-  }
-
-  const name = options.name || handler.name || 'anonymous';
-  const priority = options.priority || 0;
-
-  const extensions = _registry.get(point);
-  extensions.push({ handler, name, priority });
-
-  // Sort by priority (higher first)
-  extensions.sort((a, b) => b.priority - a.priority);
-
-  return { registered: true };
-}
-
-/**
- * Get all extensions registered at a point.
- *
- * @param {string} point - Extension point
- * @returns {Array<{ handler: Function, name: string, priority: number }>}
- */
-export function getExtensions(point) {
-  return _registry.get(point) || [];
-}
-
-/**
- * Execute all extensions at a point with given context.
- *
- * @param {string} point - Extension point
- * @param {object} context - Context passed to each handler
- * @returns {Promise<{ results: Array<{ name: string, result: any, error?: string }>, executed: number }>}
- */
-export async function executeExtensions(point, context = {}) {
-  const extensions = getExtensions(point);
-  const results = [];
-
-  for (const ext of extensions) {
-    try {
-      const result = await ext.handler(context);
-      results.push({ name: ext.name, result });
-    } catch (err) {
-      results.push({ name: ext.name, result: null, error: err.message });
-    }
-  }
-
-  return { results, executed: extensions.length };
-}
-
-/**
- * Clear all extensions (or extensions at a specific point).
- *
- * @param {string} [point] - Optional point to clear (clears all if omitted)
- */
-export function clearExtensions(point) {
-  if (point) {
-    if (_registry.has(point)) {
-      _registry.set(point, []);
-    }
-  } else {
-    for (const key of _registry.keys()) {
-      _registry.set(key, []);
-    }
-  }
-}
-
-/**
- * Get count of registered extensions.
- *
- * @returns {{ total: number, byPoint: Record<string, number> }}
- */
-export function getExtensionStats() {
-  const byPoint = {};
-  let total = 0;
-
-  for (const [point, extensions] of _registry.entries()) {
-    byPoint[point] = extensions.length;
-    total += extensions.length;
-  }
-
-  return { total, byPoint };
-}