chati-dev 4.3.1 → 4.4.1

package/src/merger/semantic-merger.js

@@ -1,292 +0,0 @@
-/**
- * @fileoverview Semantic merge engine for parallel agent outputs.
- *
- * Detects file-level, import, and naming conflicts between
- * changes produced by concurrent agents, and applies merge
- * strategies (conservative or latest-wins).
- *
- * Constitution Protocol 5 — Two-Layer Handoff.
- */
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-/** Conflict type identifiers. */
-export const CONFLICT_TYPES = {
-  FILE_OVERLAP: 'file_overlap',
-  IMPORT_CONFLICT: 'import_conflict',
-  NAMING_CONFLICT: 'naming_conflict',
-  STRUCTURAL_CONFLICT: 'structural_conflict',
-};
-
-/** Merge strategy options. */
-export const MERGE_STRATEGIES = {
-  CONSERVATIVE: 'conservative',
-  LATEST: 'latest',
-};
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} Change
- * @property {string} agent - Agent name that produced the change
- * @property {string} file - File path affected
- * @property {string} [content] - New content (for full-file changes)
- * @property {string[]} [imports] - Import statements added
- * @property {string[]} [exports] - Export names added
- * @property {string} [timestamp] - ISO timestamp of the change
- */
-
-/**
- * @typedef {object} Conflict
- * @property {string} type - Conflict type (from CONFLICT_TYPES)
- * @property {string} file - File involved
- * @property {string[]} agents - Agents that conflict
- * @property {string} description - Human-readable description
- * @property {string} severity - 'error' | 'warning'
- */
-
-/**
- * Detect conflicts between a set of changes from different agents.
- *
- * @param {Change[]} changes
- * @returns {{ hasConflicts: boolean, conflicts: Conflict[] }}
- */
-export function detectConflicts(changes) {
-  if (!Array.isArray(changes) || changes.length < 2) {
-    return { hasConflicts: false, conflicts: [] };
-  }
-
-  const conflicts = [];
-
-  // 1. File overlap detection — multiple agents changing same file
-  const fileAgentMap = groupByFile(changes);
-  for (const [file, agentChanges] of fileAgentMap.entries()) {
-    const agents = [...new Set(agentChanges.map(c => c.agent))];
-    if (agents.length > 1) {
-      conflicts.push({
-        type: CONFLICT_TYPES.FILE_OVERLAP,
-        file,
-        agents,
-        description: `Multiple agents (${agents.join(', ')}) modified ${file}`,
-        severity: 'error',
-      });
-    }
-  }
-
-  // 2. Import conflict detection — duplicate or contradictory imports
-  const importsByFile = new Map();
-  for (const change of changes) {
-    if (!change.imports || change.imports.length === 0) continue;
-    if (!importsByFile.has(change.file)) {
-      importsByFile.set(change.file, []);
-    }
-    importsByFile.get(change.file).push({ agent: change.agent, imports: change.imports });
-  }
-
-  for (const [file, importSets] of importsByFile.entries()) {
-    if (importSets.length < 2) continue;
-
-    // Check for duplicate imports from different agents
-    const allImports = new Map();
-    for (const { agent, imports } of importSets) {
-      for (const imp of imports) {
-        const normalized = normalizeImport(imp);
-        if (allImports.has(normalized)) {
-          const existing = allImports.get(normalized);
-          if (existing.agent !== agent) {
-            conflicts.push({
-              type: CONFLICT_TYPES.IMPORT_CONFLICT,
-              file,
-              agents: [existing.agent, agent],
-              description: `Duplicate import "${normalized}" from agents ${existing.agent} and ${agent}`,
-              severity: 'warning',
-            });
-          }
-        } else {
-          allImports.set(normalized, { agent, raw: imp });
-        }
-      }
-    }
-  }
-
-  // 3. Naming conflict detection — same export name from different agents
-  const exportsByName = new Map();
-  for (const change of changes) {
-    if (!change.exports || change.exports.length === 0) continue;
-    for (const exp of change.exports) {
-      if (!exportsByName.has(exp)) {
-        exportsByName.set(exp, []);
-      }
-      exportsByName.get(exp).push({ agent: change.agent, file: change.file });
-    }
-  }
-
-  for (const [name, sources] of exportsByName.entries()) {
-    const uniqueAgents = [...new Set(sources.map(s => s.agent))];
-    if (uniqueAgents.length > 1) {
-      const files = [...new Set(sources.map(s => s.file))];
-      conflicts.push({
-        type: CONFLICT_TYPES.NAMING_CONFLICT,
-        file: files[0],
-        agents: uniqueAgents,
-        description: `Export name "${name}" defined by multiple agents: ${uniqueAgents.join(', ')}`,
-        severity: 'error',
-      });
-    }
-  }
-
-  return {
-    hasConflicts: conflicts.length > 0,
-    conflicts,
-  };
-}
-
-/**
- * Merge changes from multiple agents using a strategy.
- *
- * @param {Change[]} changes
- * @param {string} [strategy='conservative'] - Merge strategy
- * @returns {{ merged: Change[], skipped: Change[], strategy: string }}
- */
-export function mergeChanges(changes, strategy = MERGE_STRATEGIES.CONSERVATIVE) {
-  if (!Array.isArray(changes) || changes.length === 0) {
-    return { merged: [], skipped: [], strategy };
-  }
-
-  if (changes.length === 1) {
-    return { merged: [...changes], skipped: [], strategy };
-  }
-
-  const fileAgentMap = groupByFile(changes);
-  const merged = [];
-  const skipped = [];
-
-  for (const [, agentChanges] of fileAgentMap.entries()) {
-    const agents = [...new Set(agentChanges.map(c => c.agent))];
-
-    if (agents.length === 1) {
-      // No conflict — include all changes for this file
-      merged.push(...agentChanges);
-      continue;
-    }
-
-    // Conflict resolution based on strategy
-    if (strategy === MERGE_STRATEGIES.LATEST) {
-      // Latest wins — sort by timestamp, take the most recent
-      const sorted = [...agentChanges].sort((a, b) => {
-        const tA = a.timestamp ? new Date(a.timestamp).getTime() : 0;
-        const tB = b.timestamp ? new Date(b.timestamp).getTime() : 0;
-        return tB - tA;
-      });
-      merged.push(sorted[0]);
-      skipped.push(...sorted.slice(1));
-    } else {
-      // Conservative — keep the first agent's changes, skip later ones
-      const sorted = [...agentChanges].sort((a, b) => {
-        const tA = a.timestamp ? new Date(a.timestamp).getTime() : 0;
-        const tB = b.timestamp ? new Date(b.timestamp).getTime() : 0;
-        return tA - tB;
-      });
-      merged.push(sorted[0]);
-      skipped.push(...sorted.slice(1));
-    }
-  }
-
-  return { merged, skipped, strategy };
-}
-
-/**
- * Validate that a merged result is structurally sound.
- *
- * @param {string} original - Original file content
- * @param {string} merged - Merged file content
- * @returns {{ valid: boolean, issues: string[] }}
- */
-export function validateMergedResult(original, merged) {
-  const issues = [];
-
-  if (!merged || typeof merged !== 'string') {
-    issues.push('Merged content is empty or not a string');
-    return { valid: false, issues };
-  }
-
-  // Check for obvious syntax issues
-
-  // 1. Balanced braces
-  const openBraces = (merged.match(/\{/g) || []).length;
-  const closeBraces = (merged.match(/\}/g) || []).length;
-  if (openBraces !== closeBraces) {
-    issues.push(`Unbalanced braces: ${openBraces} open, ${closeBraces} close`);
-  }
-
-  // 2. Balanced parentheses
-  const openParens = (merged.match(/\(/g) || []).length;
-  const closeParens = (merged.match(/\)/g) || []).length;
-  if (openParens !== closeParens) {
-    issues.push(`Unbalanced parentheses: ${openParens} open, ${closeParens} close`);
-  }
-
-  // 3. Balanced brackets
-  const openBrackets = (merged.match(/\[/g) || []).length;
-  const closeBrackets = (merged.match(/\]/g) || []).length;
-  if (openBrackets !== closeBrackets) {
-    issues.push(`Unbalanced brackets: ${openBrackets} open, ${closeBrackets} close`);
-  }
-
-  // 4. Check that imports haven't been duplicated
-  const importLines = merged.match(/^import\s+.+$/gm) || [];
-  const normalizedImports = importLines.map(normalizeImport);
-  const uniqueImports = new Set(normalizedImports);
-  if (uniqueImports.size < normalizedImports.length) {
-    issues.push(`Duplicate imports detected (${normalizedImports.length - uniqueImports.size} duplicates)`);
-  }
-
-  // 5. Check content wasn't completely destroyed
-  if (original && merged.length < original.length * 0.5) {
-    issues.push('Merged content is less than 50% of original size — possible data loss');
-  }
-
-  return {
-    valid: issues.length === 0,
-    issues,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Group changes by file path.
- *
- * @param {Change[]} changes
- * @returns {Map<string, Change[]>}
- */
-function groupByFile(changes) {
-  const map = new Map();
-  for (const change of changes) {
-    if (!change.file) continue;
-    if (!map.has(change.file)) {
-      map.set(change.file, []);
-    }
-    map.get(change.file).push(change);
-  }
-  return map;
-}
-
-/**
- * Normalize an import statement for comparison.
- *
- * @param {string} importStr
- * @returns {string}
- */
-function normalizeImport(importStr) {
-  return importStr
-    .replace(/['"]/g, "'")
-    .replace(/\s+/g, ' ')
-    .trim();
-}

package/src/preview/detector.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Framework and dev command detection for User Preview.
- * Analyzes the project directory to determine what dev server to run.
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Framework detection rules (checked in priority order).
- * Framework-specific config files take precedence over generic package.json scripts.
- */
-const FRAMEWORK_DETECTORS = [
-  {
-    files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
-    framework: 'nextjs',
-    defaultPort: 3000,
-    kind: 'fullstack',
-  },
-  {
-    files: ['nuxt.config.js', 'nuxt.config.ts'],
-    framework: 'nuxt',
-    defaultPort: 3000,
-    kind: 'fullstack',
-  },
-  {
-    files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'],
-    framework: 'vite',
-    defaultPort: 5173,
-    kind: 'frontend',
-  },
-  {
-    files: ['angular.json'],
-    framework: 'angular',
-    defaultPort: 4200,
-    kind: 'frontend',
-  },
-  {
-    files: ['svelte.config.js'],
-    framework: 'sveltekit',
-    defaultPort: 5173,
-    kind: 'frontend',
-  },
-  {
-    files: ['astro.config.mjs', 'astro.config.ts'],
-    framework: 'astro',
-    defaultPort: 4321,
-    kind: 'frontend',
-  },
-  {
-    files: ['manage.py'],
-    framework: 'django',
-    defaultPort: 8000,
-    kind: 'fullstack',
-  },
-];
-
-/**
- * API framework packages — if found in dependencies, the project is an API.
- */
-const API_PACKAGES = ['express', 'fastify', 'koa', 'hapi', 'nest', '@nestjs/core', 'restify'];
-
-/**
- * Preferred npm script names in priority order.
- */
-const SCRIPT_PRIORITY = ['dev', 'start', 'serve', 'preview'];
-
-/**
- * Detect the dev command for a project.
- *
- * Detection priority:
- *   1. Framework-specific config files (next.config.*, vite.config.*, etc.)
- *   2. package.json scripts (dev > start > serve > preview)
- *   3. Static index.html fallback (npx serve .)
- *   4. null if nothing detected (CLI tools, libraries)
- *
- * @param {string} projectDir - Absolute path to the project root
- * @returns {{ command: string, args: string[], description: string, framework: string, defaultPort: number } | null}
- */
-export function detectDevCommand(projectDir) {
-  // 1. Framework-specific config files
-  for (const detector of FRAMEWORK_DETECTORS) {
-    if (detector.files.some((f) => existsSync(join(projectDir, f)))) {
-      return resolveFrameworkCommand(projectDir, detector);
-    }
-  }
-
-  // 2. package.json scripts
-  const pkgPath = join(projectDir, 'package.json');
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      const scripts = pkg.scripts || {};
-
-      for (const script of SCRIPT_PRIORITY) {
-        if (scripts[script]) {
-          const defaultPort = 3000;
-          const command = script === 'start' ? 'npm' : 'npm';
-          const args = script === 'start' ? ['start'] : ['run', script];
-
-          return {
-            command,
-            args,
-            description: script === 'start' ? 'npm start' : `npm run ${script}`,
-            framework: 'node',
-            defaultPort,
-          };
-        }
-      }
-    } catch { /* expected: operation may fail gracefully */
-      // Invalid package.json — skip
-    }
-  }
-
-  // 3. Static index.html fallback
-  if (existsSync(join(projectDir, 'index.html'))) {
-    return {
-      command: 'npx',
-      args: ['serve', '.'],
-      description: 'Static file server (npx serve)',
-      framework: 'static',
-      defaultPort: 3000,
-    };
-  }
-
-  // 4. Nothing detected
-  return null;
-}
-
-/**
- * Detect the kind of project for UX messaging.
- *
- * @param {string} projectDir - Absolute path to the project root
- * @returns {'frontend'|'api'|'fullstack'|'cli'|'library'|'static'}
- */
-export function detectProjectKind(projectDir) {
-  // Check framework-specific configs first
-  for (const detector of FRAMEWORK_DETECTORS) {
-    if (detector.files.some((f) => existsSync(join(projectDir, f)))) {
-      return detector.kind;
-    }
-  }
-
-  // Check package.json for API framework deps
-  const pkgPath = join(projectDir, 'package.json');
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      const allDeps = {
-        ...pkg.dependencies,
-        ...pkg.devDependencies,
-      };
-
-      if (API_PACKAGES.some((p) => allDeps[p])) {
-        return 'api';
-      }
-
-      // Has bin field → CLI tool
-      if (pkg.bin) {
-        return 'cli';
-      }
-
-      // Has main/exports but no scripts → library
-      if ((pkg.main || pkg.exports) && !pkg.scripts?.dev && !pkg.scripts?.start) {
-        return 'library';
-      }
-    } catch { /* expected: operation may fail gracefully */
-      // Invalid package.json
-    }
-  }
-
-  // Static HTML
-  if (existsSync(join(projectDir, 'index.html'))) {
-    return 'static';
-  }
-
-  // Python projects
-  if (existsSync(join(projectDir, 'manage.py'))) {
-    return 'fullstack';
-  }
-
-  // Default: assume library/CLI (no preview server)
-  return 'library';
-}
-
-/**
- * Resolve the dev command for a known framework.
- *
- * @param {string} projectDir
- * @param {object} detector - Framework detector entry
- * @returns {{ command: string, args: string[], description: string, framework: string, defaultPort: number }}
- */
-function resolveFrameworkCommand(projectDir, detector) {
-  const { framework, defaultPort } = detector;
-
-  // Django has its own command
-  if (framework === 'django') {
-    return {
-      command: 'python',
-      args: ['manage.py', 'runserver'],
-      description: 'Django dev server',
-      framework,
-      defaultPort,
-    };
-  }
-
-  // Node-based frameworks: prefer package.json scripts
-  const pkgPath = join(projectDir, 'package.json');
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-      const scripts = pkg.scripts || {};
-
-      for (const script of SCRIPT_PRIORITY) {
-        if (scripts[script]) {
-          return {
-            command: 'npm',
-            args: script === 'start' ? ['start'] : ['run', script],
-            description: `${framework} (npm ${script === 'start' ? 'start' : `run ${script}`})`,
-            framework,
-            defaultPort,
-          };
-        }
-      }
-    } catch { /* expected: operation may fail gracefully */
-      // Fall through to default
-    }
-  }
-
-  // Fallback for Node frameworks without scripts
-  return {
-    command: 'npm',
-    args: ['run', 'dev'],
-    description: `${framework} dev server`,
-    framework,
-    defaultPort,
-  };
-}

package/src/preview/index.js

@@ -1,20 +0,0 @@
-/**
- * @fileoverview User Preview module — local server for pre-deploy validation.
- *
- * Detects the project's framework, spawns a dev server on an available port,
- * captures logs for Dev agent context, and manages server lifecycle.
- *
- * Usage:
- *   import { detectDevCommand, findAvailablePort, launchPreview } from './preview/index.js';
- *
- *   const devCmd = detectDevCommand(projectDir);
- *   const port = await findAvailablePort(devCmd.defaultPort);
- *   const handle = await launchPreview(projectDir, { ...devCmd, port });
- *   // ... user validates ...
- *   // handle.logs.toContext() → send to Dev agent
- *   // await handle.kill() → when user decides to stop
- */
-
-export { detectDevCommand, detectProjectKind } from './detector.js';
-export { findAvailablePort, launchPreview, waitForServer, openBrowser } from './launcher.js';
-export { LogBuffer } from './log-buffer.js';