chati-dev 4.3.0 → 4.4.0

package/src/config/agent-customizer.js

@@ -1,231 +0,0 @@
-/**
- * @fileoverview Agent customization via per-project override files.
- *
- * Loads `.customize.yaml` files from `chati.dev/customize/<agent>.yaml`
- * and applies overrides to agent prompts.
- *
- * Constitution Article XVI — Model Governance.
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import yaml from 'js-yaml';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/**
- * Get the customize directory for a given project.
- * Supports both .chati.dev/ and chati.dev/ structures.
- * @param {string} projectDir
- * @returns {string} Relative path from project root
- */
-function getCustomizeDir(projectDir) {
-  return `${resolveFrameworkDir(projectDir)}/customize`;
-}
-
-/** Valid override fields that customizations can set. */
-export const VALID_OVERRIDE_FIELDS = [
-  'model',
-  'extra_context',
-  'skip_sections',
-  'add_sections',
-  'provider',
-  'timeout',
-  'max_iterations',
-];
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} Customization
- * @property {boolean} found - Whether a customization file was found
- * @property {string} [model] - Override model name
- * @property {string} [extra_context] - Additional context to inject
- * @property {string[]} [skip_sections] - Sections to omit from prompt
- * @property {{ name: string, content: string }[]} [add_sections] - Sections to append
- * @property {string} [provider] - Override provider name
- * @property {number} [timeout] - Override timeout in ms
- * @property {number} [max_iterations] - Override max iterations
- */
-
-/**
- * Load customization for a specific agent.
- *
- * @param {string} projectDir - Project root directory
- * @param {string} agentName - Agent name (e.g., 'brief', 'dev')
- * @returns {{ found: boolean, overrides: Customization }}
- */
-export function loadCustomization(projectDir, agentName) {
-  if (!projectDir || !agentName) {
-    return { found: false, overrides: {} };
-  }
-
-  const customizePath = join(projectDir, getCustomizeDir(projectDir), `${agentName}.yaml`);
-
-  if (!existsSync(customizePath)) {
-    return { found: false, overrides: {} };
-  }
-
-  try {
-    const raw = readFileSync(customizePath, 'utf-8');
-    const parsed = yaml.load(raw);
-
-    if (!parsed || typeof parsed !== 'object') {
-      return { found: true, overrides: {} };
-    }
-
-    // Filter to valid override fields only
-    const overrides = {};
-    for (const field of VALID_OVERRIDE_FIELDS) {
-      if (parsed[field] !== undefined) {
-        overrides[field] = parsed[field];
-      }
-    }
-
-    return { found: true, overrides };
-  } catch { /* expected: content may be malformed */
-    return { found: false, overrides: {} };
-  }
-}
-
-/**
- * Apply customization overrides to an agent prompt.
- *
- * @param {string} agentPrompt - Original agent prompt
- * @param {Customization} customization - Customization overrides
- * @returns {string} Modified prompt
- */
-export function applyCustomization(agentPrompt, customization) {
-  if (!agentPrompt || !customization) {
-    return agentPrompt || '';
-  }
-
-  let prompt = agentPrompt;
-
-  // Skip sections
-  if (customization.skip_sections && Array.isArray(customization.skip_sections)) {
-    for (const sectionName of customization.skip_sections) {
-      // Match section heading + all content until the next heading of same or higher level, or end of text
-      // Two-pass approach: try lookahead for next heading, then fallback to end
-      const headingPattern = new RegExp(
-        `^(#{1,3})\\s+${escapeRegex(sectionName)}[^\\n]*\\n([\\s\\S]*?)(?=^#{1,3}\\s)`,
-        'gm'
-      );
-      let replaced = prompt.replace(headingPattern, '');
-      if (replaced === prompt) {
-        // Section is at the end — no next heading follows
-        const endPattern = new RegExp(
-          `^(#{1,3})\\s+${escapeRegex(sectionName)}[^\\n]*\\n[\\s\\S]*$`,
-          'gm'
-        );
-        replaced = prompt.replace(endPattern, '');
-      }
-      prompt = replaced;
-    }
-  }
-
-  // Add extra context at the end
-  if (customization.extra_context && typeof customization.extra_context === 'string') {
-    prompt += `\n\n---\n\n## Additional Context\n\n${customization.extra_context}\n`;
-  }
-
-  // Add new sections
-  if (customization.add_sections && Array.isArray(customization.add_sections)) {
-    for (const section of customization.add_sections) {
-      if (section.name && section.content) {
-        prompt += `\n\n## ${section.name}\n\n${section.content}\n`;
-      }
-    }
-  }
-
-  return prompt;
-}
-
-/**
- * Validate a customization object.
- *
- * @param {object} customization
- * @returns {{ valid: boolean, errors: string[] }}
- */
-export function validateCustomization(customization) {
-  const errors = [];
-
-  if (!customization || typeof customization !== 'object') {
-    errors.push('Customization must be a non-null object');
-    return { valid: false, errors };
-  }
-
-  // Check for unknown fields
-  for (const key of Object.keys(customization)) {
-    if (!VALID_OVERRIDE_FIELDS.includes(key)) {
-      errors.push(`Unknown override field: "${key}"`);
-    }
-  }
-
-  // Validate model
-  if (customization.model !== undefined && typeof customization.model !== 'string') {
-    errors.push('model must be a string');
-  }
-
-  // Validate extra_context
-  if (customization.extra_context !== undefined && typeof customization.extra_context !== 'string') {
-    errors.push('extra_context must be a string');
-  }
-
-  // Validate skip_sections
-  if (customization.skip_sections !== undefined) {
-    if (!Array.isArray(customization.skip_sections)) {
-      errors.push('skip_sections must be an array');
-    } else if (customization.skip_sections.some(s => typeof s !== 'string')) {
-      errors.push('skip_sections must contain only strings');
-    }
-  }
-
-  // Validate add_sections
-  if (customization.add_sections !== undefined) {
-    if (!Array.isArray(customization.add_sections)) {
-      errors.push('add_sections must be an array');
-    } else {
-      for (const section of customization.add_sections) {
-        if (!section.name || !section.content) {
-          errors.push('Each add_section must have name and content');
-        }
-      }
-    }
-  }
-
-  // Validate timeout
-  if (customization.timeout !== undefined) {
-    if (typeof customization.timeout !== 'number' || customization.timeout <= 0) {
-      errors.push('timeout must be a positive number');
-    }
-  }
-
-  // Validate max_iterations
-  if (customization.max_iterations !== undefined) {
-    if (typeof customization.max_iterations !== 'number' || customization.max_iterations <= 0) {
-      errors.push('max_iterations must be a positive number');
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Escape special regex characters in a string.
- *
- * @param {string} str
- * @returns {string}
- */
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/src/decision/analyzer.js

@@ -1,291 +0,0 @@
-/**
- * Impact Analyzer - Dependency analysis for chati.dev
- * Analyzes impact of changes via dependency graph traversal
- *
- * @module decision/analyzer
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import yaml from 'js-yaml';
-import { resolveFrameworkDir } from '../utils/framework-dir.js';
-import { flattenEntitiesFromRegistry } from '../utils/flatten-entities.js';
-
-/**
- * Analyze impact of changing an entity.
- * Builds dependency graph from entity-registry and calculates affected entities.
- *
- * @param {string} projectDir
- * @param {string} entityPath - Path of entity being changed
- * @returns {{ impactLevel: 'low'|'medium'|'high'|'critical', affectedEntities: object[], dependencyChain: string[] }}
- */
-export function analyzeImpact(projectDir, entityPath) {
-  const graph = buildDependencyGraph(projectDir);
-  const affectedPaths = getTransitiveDependents(graph, entityPath);
-
-  // Determine impact level based on affected entity count
-  let impactLevel;
-  const affectedCount = affectedPaths.length;
-
-  if (affectedCount === 0) {
-    impactLevel = 'low';
-  } else if (affectedCount <= 2) {
-    impactLevel = 'low';
-  } else if (affectedCount <= 5) {
-    impactLevel = 'medium';
-  } else if (affectedCount <= 10) {
-    impactLevel = 'high';
-  } else {
-    impactLevel = 'critical';
-  }
-
-  // Load entity details
-  const registryPath = join(projectDir, resolveFrameworkDir(projectDir), 'entity-registry.yaml');
-  const registry = existsSync(registryPath)
-    ? yaml.load(readFileSync(registryPath, 'utf8'))
-    : { entities: {} };
-
-  const allEntities = flattenEntitiesFromRegistry(registry);
-  const entityMap = new Map(allEntities.map(e => [e.path, e]));
-
-  const affectedEntities = affectedPaths.map(path => {
-    const entity = entityMap.get(path);
-    return {
-      path,
-      type: entity?.type || 'unknown',
-      name: entity?.name || path.split('/').pop()
-    };
-  });
-
-  return {
-    impactLevel,
-    affectedEntities,
-    dependencyChain: affectedPaths
-  };
-}
-
-/**
- * Build dependency graph from entity registry.
- * @param {string} projectDir
- * @returns {Map<string, string[]>} Map of entityPath -> [dependentPaths]
- */
-export function buildDependencyGraph(projectDir) {
-  const registryPath = join(projectDir, resolveFrameworkDir(projectDir), 'entity-registry.yaml');
-  const graph = new Map();
-
-  if (!existsSync(registryPath)) {
-    return graph;
-  }
-
-  const registry = yaml.load(readFileSync(registryPath, 'utf8'));
-  const entities = flattenEntitiesFromRegistry(registry);
-
-  // Initialize graph with all entities
-  entities.forEach(entity => {
-    if (entity.path) {
-      graph.set(entity.path, []);
-    }
-  });
-
-  // Build reverse dependency map (who depends on whom)
-  entities.forEach(entity => {
-    if (entity.dependencies && Array.isArray(entity.dependencies)) {
-      entity.dependencies.forEach(depPath => {
-        if (!graph.has(depPath)) {
-          graph.set(depPath, []);
-        }
-        // Add entity.path as dependent of depPath
-        const dependents = graph.get(depPath);
-        if (!dependents.includes(entity.path)) {
-          dependents.push(entity.path);
-        }
-      });
-    }
-  });
-
-  return graph;
-}
-
-/**
- * Get all entities that depend on a given entity (transitive).
- * Uses BFS traversal.
- * @param {Map<string, string[]>} graph
- * @param {string} entityPath
- * @returns {string[]} All affected paths
- */
-export function getTransitiveDependents(graph, entityPath) {
-  const visited = new Set();
-  const queue = [entityPath];
-  const result = [];
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-
-    if (visited.has(current)) {
-      continue;
-    }
-
-    visited.add(current);
-
-    // Get direct dependents
-    const dependents = graph.get(current) || [];
-
-    dependents.forEach(dependent => {
-      if (!visited.has(dependent)) {
-        queue.push(dependent);
-        result.push(dependent);
-      }
-    });
-  }
-
-  return result;
-}
-
-/**
- * Score a decision option based on multiple criteria using TF-IDF-inspired
- * keyword relevance scoring.
- *
- * @param {{ name: string, description?: string, keywords?: string[] }} option
- * @param {{ requirements?: string[], constraints?: string[], existingEntities?: string[] }} context
- * @returns {{ score: number, alignment: number, complexity: number, reuse: number, breakdown: object }}
- */
-export function scoreDecision(option, context = {}) {
-  if (!option || !option.name) {
-    return { score: 0, alignment: 0, complexity: 0, reuse: 0, breakdown: {} };
-  }
-
-  const requirements = context.requirements || [];
-  const constraints = context.constraints || [];
-  const existingEntities = context.existingEntities || [];
-
-  // 1. Alignment score — how well does option match requirements?
-  const optionText = `${option.name} ${option.description || ''} ${(option.keywords || []).join(' ')}`.toLowerCase();
-  const alignment = computeRelevance(optionText, requirements);
-
-  // 2. Complexity score (inverse — lower complexity = higher score)
-  const complexitySignals = ['microservice', 'distributed', 'multi-tenant', 'real-time', 'concurrent', 'migration'];
-  let complexityCount = 0;
-  for (const signal of complexitySignals) {
-    if (optionText.includes(signal)) {
-      complexityCount++;
-    }
-  }
-  const complexity = Math.max(0, 1 - complexityCount * 0.15);
-
-  // 3. Reuse score — overlap with existing entities (decision priority: REUSE > ADAPT > CREATE)
-  let reuse = 0;
-  if (existingEntities.length > 0) {
-    const optionWords = new Set(optionText.split(/\s+/));
-    let matchCount = 0;
-    for (const entity of existingEntities) {
-      const entityWords = entity.toLowerCase().split(/[\s/.-]+/);
-      for (const word of entityWords) {
-        if (word.length > 3 && optionWords.has(word)) {
-          matchCount++;
-          break;
-        }
-      }
-    }
-    reuse = existingEntities.length > 0 ? matchCount / existingEntities.length : 0;
-  }
-
-  // 4. Constraint satisfaction
-  let constraintScore = 1;
-  if (constraints.length > 0) {
-    let satisfied = 0;
-    for (const constraint of constraints) {
-      const constraintWords = constraint.toLowerCase().split(/\s+/);
-      const hasMatch = constraintWords.some(w => w.length > 3 && optionText.includes(w));
-      if (hasMatch) satisfied++;
-    }
-    constraintScore = constraints.length > 0 ? satisfied / constraints.length : 1;
-  }
-
-  // Weighted final score
-  const score = Math.round(
-    (alignment * 0.4 + complexity * 0.2 + reuse * 0.25 + constraintScore * 0.15) * 100
-  ) / 100;
-
-  return {
-    score,
-    alignment: Math.round(alignment * 100) / 100,
-    complexity: Math.round(complexity * 100) / 100,
-    reuse: Math.round(reuse * 100) / 100,
-    breakdown: {
-      alignment: { weight: 0.4, raw: alignment },
-      complexity: { weight: 0.2, raw: complexity },
-      reuse: { weight: 0.25, raw: reuse },
-      constraints: { weight: 0.15, raw: constraintScore },
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// TF-IDF Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Compute TF-IDF-inspired relevance between text and a set of documents.
- *
- * @param {string} text - Source text
- * @param {string[]} documents - Reference documents (requirements, etc.)
- * @returns {number} Relevance score (0-1)
- */
-function computeRelevance(text, documents) {
-  if (!text || documents.length === 0) return 0;
-
-  const textWords = tokenize(text);
-  if (textWords.length === 0) return 0;
-
-  // Build document frequency map
-  const docCount = documents.length;
-  const df = new Map();
-
-  for (const doc of documents) {
-    const words = new Set(tokenize(doc.toLowerCase()));
-    for (const word of words) {
-      df.set(word, (df.get(word) || 0) + 1);
-    }
-  }
-
-  // Calculate TF-IDF score for each text word
-  const textWordSet = new Set(textWords);
-  let totalScore = 0;
-
-  for (const word of textWordSet) {
-    const termFreq = textWords.filter(w => w === word).length / textWords.length;
-    const docFreq = df.get(word) || 0;
-
-    if (docFreq > 0) {
-      // IDF = log(N / df) — boost rare terms
-      const idf = Math.log((docCount + 1) / (docFreq + 1)) + 1;
-      totalScore += termFreq * idf;
-    }
-  }
-
-  // Normalize to 0-1 range
-  const maxPossible = Math.log(docCount + 1) + 1;
-  return maxPossible > 0 ? Math.min(totalScore / maxPossible, 1) : 0;
-}
-
-/**
- * Tokenize text into meaningful words (skip stopwords and short tokens).
- *
- * @param {string} text
- * @returns {string[]}
- */
-function tokenize(text) {
-  const stopwords = new Set([
-    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
-    'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-    'should', 'may', 'might', 'shall', 'can', 'this', 'that', 'these',
-    'those', 'it', 'its', 'not', 'no', 'from', 'as', 'into', 'all',
-  ]);
-
-  return text
-    .toLowerCase()
-    .split(/[\s,.;:!?()[\]{}"'`/\\-]+/)
-    .filter(w => w.length > 2 && !stopwords.has(w));
-}
-