chati-dev 4.3.1 → 4.4.1

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));
-}
-

package/src/decision/engine.js

@@ -1,250 +0,0 @@
-/**
- * Decision Engine - Core COMPASS module for chati.dev
- * Analyzes intent and recommends: REUSE (>=90%), ADAPT (60-89%), CREATE (<60%)
- *
- * NOTE: This module handles entity-level routing (registry lookup).
- * For intent-level similarity scoring (weighted keyword + purpose),
- * see `intelligence/decision-engine.js` (calculateIntentSimilarity).
- *
- * @module decision/engine
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } 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 a request against existing entities and recommend action.
- * Uses keyword matching to find similar existing artifacts.
- *
- * @param {string} projectDir
- * @param {object} request - { description, type, keywords, agent }
- * @returns {{ recommendation: 'REUSE'|'ADAPT'|'CREATE', score: number, matches: object[], reasoning: string }}
- */
-export function analyzeRequest(projectDir, request) {
-  const registryPath = join(projectDir, resolveFrameworkDir(projectDir), 'entity-registry.yaml');
-
-  if (!existsSync(registryPath)) {
-    return {
-      recommendation: 'CREATE',
-      score: 0,
-      matches: [],
-      reasoning: 'No entity registry found - first artifact in project'
-    };
-  }
-
-  const registry = yaml.load(readFileSync(registryPath, 'utf8'));
-  const entities = flattenEntitiesFromRegistry(registry);
-
-  // Calculate similarity scores for all entities
-  const scoredMatches = entities
-    .map(entity => ({
-      entity,
-      score: calculateSimilarity(request, entity)
-    }))
-    .filter(match => match.score > 0)
-    .sort((a, b) => b.score - a.score);
-
-  const topScore = scoredMatches.length > 0 ? scoredMatches[0].score : 0;
-  const topMatches = scoredMatches.slice(0, 5).map(m => ({
-    path: m.entity.path,
-    type: m.entity.type,
-    score: m.score,
-    purpose: m.entity.purpose || 'No purpose defined'
-  }));
-
-  let recommendation;
-  let reasoning;
-
-  if (topScore >= 90) {
-    recommendation = 'REUSE';
-    reasoning = `High similarity (${topScore}%) - existing artifact meets requirements`;
-  } else if (topScore >= 60) {
-    recommendation = 'ADAPT';
-    reasoning = `Moderate similarity (${topScore}%) - adapt existing artifact`;
-  } else {
-    recommendation = 'CREATE';
-    reasoning = topScore > 0
-      ? `Low similarity (${topScore}%) - create new artifact`
-      : 'No similar artifacts found - create new';
-  }
-
-  const decision = {
-    timestamp: new Date().toISOString(),
-    request: {
-      description: request.description,
-      type: request.type,
-      keywords: request.keywords,
-      agent: request.agent
-    },
-    recommendation,
-    score: topScore,
-    reasoning,
-    topMatches: topMatches.slice(0, 3)
-  };
-
-  recordDecision(projectDir, decision);
-
-  return {
-    recommendation,
-    score: topScore,
-    matches: topMatches,
-    reasoning
-  };
-}
-
-/**
- * Calculate similarity between a request and an entity.
- * Uses keyword overlap (Jaccard similarity) + type matching.
- *
- * @param {object} request - { keywords, type }
- * @param {object} entity - { keywords, type, purpose }
- * @returns {number} Score 0-100
- */
-export function calculateSimilarity(request, entity) {
-  // Normalize and collect keywords
-  const requestKeywords = new Set(
-    (request.keywords || []).map(k => k.toLowerCase())
-  );
-
-  const entityKeywords = new Set();
-
-  // Extract from entity keywords (primary source)
-  if (entity.keywords) {
-    entity.keywords.forEach(k => entityKeywords.add(k.toLowerCase()));
-  }
-
-  // Extract from entity name (secondary source - only key terms)
-  if (entity.name) {
-    const nameWords = entity.name
-      .toLowerCase()
-      .replace(/[._-]/g, ' ')
-      .split(/\W+/)
-      .filter(w => w.length > 3);
-    nameWords.forEach(w => entityKeywords.add(w));
-  }
-
-  if (requestKeywords.size === 0 || entityKeywords.size === 0) {
-    return 0;
-  }
-
-  // Calculate Jaccard similarity
-  const intersection = new Set(
-    [...requestKeywords].filter(k => entityKeywords.has(k))
-  );
-  const union = new Set([...requestKeywords, ...entityKeywords]);
-
-  let score = (intersection.size / union.size) * 100;
-
-  // Add bonus points for type match (additive, not multiplicative)
-  if (request.type && entity.type && request.type === entity.type) {
-    score = Math.min(100, score + 25);
-  }
-
-  // Add bonus for high intersection ratio (more matches = better)
-  const intersectionRatio = intersection.size / requestKeywords.size;
-  if (intersectionRatio >= 0.8) {
-    score = Math.min(100, score + 15);
-  } else if (intersectionRatio >= 0.5) {
-    score = Math.min(100, score + 10);
-  }
-
-  return Math.round(score);
-}
-
-/**
- * Get decision history for auditing.
- * @param {string} projectDir
- * @returns {object[]} Recent decisions
- */
-export function getDecisionHistory(projectDir) {
-  const historyPath = join(projectDir, '.chati', 'decisions', 'history.json');
-
-  if (!existsSync(historyPath)) {
-    return [];
-  }
-
-  try {
-    const content = readFileSync(historyPath, 'utf8');
-    const data = JSON.parse(content);
-    return data.decisions || [];
-  } catch { /* expected: file may not exist */
-    return [];
-  }
-}
-
-/**
- * Record a decision for audit trail.
- * @param {string} projectDir
- * @param {object} decision
- */
-export function recordDecision(projectDir, decision) {
-  const decisionsDir = join(projectDir, '.chati', 'decisions');
-  const historyPath = join(decisionsDir, 'history.json');
-
-  // Ensure directory exists
-  if (!existsSync(decisionsDir)) {
-    mkdirSync(decisionsDir, { recursive: true });
-  }
-
-  let history = { decisions: [] };
-
-  if (existsSync(historyPath)) {
-    try {
-      const content = readFileSync(historyPath, 'utf8');
-      history = JSON.parse(content);
-    } catch { /* expected: file may not exist */
-      // Keep empty history if parse fails
-    }
-  }
-
-  history.decisions = history.decisions || [];
-  history.decisions.push(decision);
-
-  // Keep last 100 decisions
-  if (history.decisions.length > 100) {
-    history.decisions = history.decisions.slice(-100);
-  }
-
-  writeFileSync(historyPath, JSON.stringify(history, null, 2), 'utf8');
-}
-
-/**
- * Get engine statistics.
- * @param {string} projectDir
- * @returns {object} { totalDecisions, byRecommendation: { REUSE, ADAPT, CREATE }, avgScore }
- */
-export function getEngineStats(projectDir) {
-  const history = getDecisionHistory(projectDir);
-
-  const stats = {
-    totalDecisions: history.length,
-    byRecommendation: {
-      REUSE: 0,
-      ADAPT: 0,
-      CREATE: 0
-    },
-    avgScore: 0
-  };
-
-  if (history.length === 0) {
-    return stats;
-  }
-
-  let totalScore = 0;
-
-  history.forEach(decision => {
-    if (decision.recommendation) {
-      stats.byRecommendation[decision.recommendation] =
-        (stats.byRecommendation[decision.recommendation] || 0) + 1;
-    }
-    totalScore += decision.score || 0;
-  });
-
-  stats.avgScore = Math.round(totalScore / history.length);
-
-  return stats;
-}
-

package/src/decision/index.js

@@ -1,38 +0,0 @@
-/**
- * Decision Engine - COMPASS for chati.dev
- * Barrel exports for decision engine modules
- *
- * @module decision
- */
-
-export {
-  analyzeRequest,
-  calculateSimilarity,
-  getDecisionHistory,
-  recordDecision,
-  getEngineStats
-} from './engine.js';
-
-export {
-  analyzeImpact,
-  buildDependencyGraph,
-  getTransitiveDependents
-} from './analyzer.js';
-
-export {
-  updateRegistry,
-  detectNewEntities,
-  detectRemovedEntities,
-  generateEntityMeta
-} from './registry-updater.js';
-
-export {
-  healRegistry,
-  detectMissingEntities,
-  detectOrphanedEntries,
-  detectStaleMetadata,
-  detectDuplicates,
-  detectInvalidPaths,
-  detectCountMismatch,
-  applyFixes
-} from './registry-healer.js';