chati-dev 3.2.5 → 3.3.0

package/src/orchestrator/pipeline-state.js

@@ -1,223 +0,0 @@
-/**
- * @fileoverview Pipeline state persistence layer.
- * Handles reading/writing pipeline state to session.yaml.
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import yaml from 'js-yaml';
-
-/**
- * Default session file path relative to project root.
- */
-const SESSION_PATH = '.chati/session.yaml';
-
-/**
- * Get full path to session file.
- *
- * @param {string} projectDir - Project root directory
- * @returns {string}
- */
-function getSessionPath(projectDir) {
-  return join(projectDir, SESSION_PATH);
-}
-
-/**
- * Load pipeline state from session.yaml.
- *
- * @param {string} projectDir
- * @returns {{ loaded: boolean, state: object|null }}
- */
-export function loadPipelineState(projectDir) {
-  const sessionPath = getSessionPath(projectDir);
-
-  if (!existsSync(sessionPath)) {
-    return {
-      loaded: false,
-      state: null,
-    };
-  }
-
-  try {
-    const content = readFileSync(sessionPath, 'utf8');
-    const session = yaml.load(content);
-
-    // Extract pipeline-relevant fields
-    const state = {
-      phase: session.mode || 'discover',
-      isGreenfield: session.project_type === 'greenfield',
-      startedAt: session.started_at || null,
-      completedAt: session.completed_at || null,
-      agents: session.agents || {},
-      completedAgents: session.completed_agents || [],
-      currentAgent: session.current_agent || null,
-      modeTransitions: session.mode_transitions || [],
-      history: session.history || [],
-    };
-
-    return {
-      loaded: true,
-      state,
-    };
-  } catch (error) {
-    console.error(`Failed to load pipeline state: ${error.message}`);
-    return {
-      loaded: false,
-      state: null,
-    };
-  }
-}
-
-/**
- * Save pipeline state to session.yaml.
- *
- * @param {string} projectDir
- * @param {object} state
- * @returns {{ saved: boolean }}
- */
-export function savePipelineState(projectDir, state) {
-  const sessionPath = getSessionPath(projectDir);
-
-  // Ensure .chati directory exists
-  const chatDir = dirname(sessionPath);
-  if (!existsSync(chatDir)) {
-    mkdirSync(chatDir, { recursive: true });
-  }
-
-  try {
-    // Convert pipeline state to session format
-    const session = {
-      mode: state.phase,
-      project_type: state.isGreenfield ? 'greenfield' : 'brownfield',
-      started_at: state.startedAt,
-      completed_at: state.completedAt,
-      agents: state.agents,
-      completed_agents: state.completedAgents,
-      current_agent: state.currentAgent,
-      mode_transitions: state.modeTransitions,
-      history: state.history,
-      updated_at: new Date().toISOString(),
-    };
-
-    const content = yaml.dump(session, {
-      indent: 2,
-      lineWidth: 120,
-      noRefs: true,
-    });
-
-    writeFileSync(sessionPath, content, 'utf8');
-
-    return { saved: true };
-  } catch (error) {
-    console.error(`Failed to save pipeline state: ${error.message}`);
-    return { saved: false };
-  }
-}
-
-/**
- * Merge pipeline state into existing session.yaml (preserving other fields).
- *
- * @param {string} projectDir
- * @param {object} updates - Partial pipeline state updates
- * @returns {{ saved: boolean }}
- */
-export function updatePipelineState(projectDir, updates) {
-  const sessionPath = getSessionPath(projectDir);
-
-  // Load existing session or start with empty object
-  let session = {};
-  if (existsSync(sessionPath)) {
-    try {
-      const content = readFileSync(sessionPath, 'utf8');
-      session = yaml.load(content) || {};
-    } catch (error) {
-      console.error(`Failed to load existing session: ${error.message}`);
-      // Continue with empty session
-    }
-  }
-
-  // Ensure .chati directory exists
-  const chatDir = dirname(sessionPath);
-  if (!existsSync(chatDir)) {
-    mkdirSync(chatDir, { recursive: true });
-  }
-
-  try {
-    // Apply updates to session
-    if (updates.phase !== undefined) {
-      session.mode = updates.phase;
-    }
-    if (updates.isGreenfield !== undefined) {
-      session.project_type = updates.isGreenfield ? 'greenfield' : 'brownfield';
-    }
-    if (updates.startedAt !== undefined) {
-      session.started_at = updates.startedAt;
-    }
-    if (updates.completedAt !== undefined) {
-      session.completed_at = updates.completedAt;
-    }
-    if (updates.agents !== undefined) {
-      session.agents = updates.agents;
-    }
-    if (updates.completedAgents !== undefined) {
-      session.completed_agents = updates.completedAgents;
-    }
-    if (updates.currentAgent !== undefined) {
-      session.current_agent = updates.currentAgent;
-    }
-    if (updates.modeTransitions !== undefined) {
-      session.mode_transitions = updates.modeTransitions;
-    }
-    if (updates.history !== undefined) {
-      session.history = updates.history;
-    }
-
-    session.updated_at = new Date().toISOString();
-
-    const content = yaml.dump(session, {
-      indent: 2,
-      lineWidth: 120,
-      noRefs: true,
-    });
-
-    writeFileSync(sessionPath, content, 'utf8');
-
-    return { saved: true };
-  } catch (error) {
-    console.error(`Failed to update pipeline state: ${error.message}`);
-    return { saved: false };
-  }
-}
-
-/**
- * Check if session file exists.
- *
- * @param {string} projectDir
- * @returns {boolean}
- */
-export function sessionExists(projectDir) {
-  const sessionPath = getSessionPath(projectDir);
-  return existsSync(sessionPath);
-}
-
-/**
- * Delete session file.
- *
- * @param {string} projectDir
- * @returns {{ deleted: boolean }}
- */
-export function deleteSession(projectDir) {
-  const sessionPath = getSessionPath(projectDir);
-
-  if (!existsSync(sessionPath)) {
-    return { deleted: true };
-  }
-
-  try {
-    unlinkSync(sessionPath);
-    return { deleted: true };
-  } catch (error) {
-    console.error(`Failed to delete session: ${error.message}`);
-    return { deleted: false };
-  }
-}

package/src/terminal/wave-analyzer.js

@@ -1,143 +0,0 @@
-/**
- * @fileoverview Wave analyzer for task parallelization.
- *
- * Analyzes task dependencies to group them into waves —
- * sets of tasks that can execute in parallel because they
- * have no inter-dependencies.
- */
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * @typedef {object} TaskNode
- * @property {string} id - Task identifier
- * @property {string[]} dependencies - IDs of tasks this depends on
- * @property {string[]} [writeScope] - Files/dirs this task writes to
- */
-
-/**
- * @typedef {object} Wave
- * @property {number} index - Wave number (0-based)
- * @property {string[]} taskIds - Task IDs in this wave
- */
-
-// ---------------------------------------------------------------------------
-// Wave Analysis
-// ---------------------------------------------------------------------------
-
-/**
- * Build a dependency graph and compute waves using topological sorting.
- *
- * @param {TaskNode[]} tasks - Array of tasks with dependencies
- * @returns {Wave[]}
- * @throws {Error} When circular dependencies are detected
- */
-export function analyzeWaves(tasks) {
-  if (!tasks || tasks.length === 0) return [];
-
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
-  const inDegree = new Map();
-  const adjList = new Map();
-
-  // Initialize
-  for (const task of tasks) {
-    inDegree.set(task.id, 0);
-    adjList.set(task.id, []);
-  }
-
-  // Build adjacency and in-degree
-  for (const task of tasks) {
-    for (const dep of task.dependencies || []) {
-      if (taskMap.has(dep)) {
-        adjList.get(dep).push(task.id);
-        inDegree.set(task.id, (inDegree.get(task.id) || 0) + 1);
-      }
-    }
-  }
-
-  // Kahn's algorithm with wave grouping
-  const waves = [];
-  const remaining = new Set(tasks.map((t) => t.id));
-
-  while (remaining.size > 0) {
-    // Find all tasks with no pending dependencies (in-degree 0)
-    const wave = [];
-    for (const id of remaining) {
-      if ((inDegree.get(id) || 0) === 0) {
-        wave.push(id);
-      }
-    }
-
-    if (wave.length === 0) {
-      const circular = [...remaining].join(', ');
-      throw new Error(`Circular dependency detected among tasks: ${circular}`);
-    }
-
-    waves.push({ index: waves.length, taskIds: wave });
-
-    // Remove wave tasks and update in-degrees
-    for (const id of wave) {
-      remaining.delete(id);
-      for (const dependent of adjList.get(id) || []) {
-        inDegree.set(dependent, (inDegree.get(dependent) || 0) - 1);
-      }
-    }
-  }
-
-  return waves;
-}
-
-/**
- * Validate that tasks within a wave don't have write scope conflicts.
- *
- * @param {TaskNode[]} tasks - All tasks
- * @param {Wave} wave - Wave to validate
- * @returns {{ valid: boolean, conflicts: { taskA: string, taskB: string, path: string }[] }}
- */
-export function validateWaveScopes(tasks, wave) {
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
-  const conflicts = [];
-
-  const waveTasks = wave.taskIds.map((id) => taskMap.get(id)).filter(Boolean);
-
-  for (let i = 0; i < waveTasks.length; i++) {
-    for (let j = i + 1; j < waveTasks.length; j++) {
-      const scopeA = waveTasks[i].writeScope || [];
-      const scopeB = waveTasks[j].writeScope || [];
-
-      for (const pathA of scopeA) {
-        for (const pathB of scopeB) {
-          if (pathA === pathB || pathA.startsWith(pathB + '/') || pathB.startsWith(pathA + '/')) {
-            conflicts.push({
-              taskA: waveTasks[i].id,
-              taskB: waveTasks[j].id,
-              path: pathA,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  return { valid: conflicts.length === 0, conflicts };
-}
-
-/**
- * Get a summary of the wave analysis.
- *
- * @param {Wave[]} waves
- * @returns {{ totalWaves: number, totalTasks: number, maxParallel: number, sequential: boolean }}
- */
-export function getWaveSummary(waves) {
-  const totalTasks = waves.reduce((sum, w) => sum + w.taskIds.length, 0);
-  const maxParallel = Math.max(...waves.map((w) => w.taskIds.length), 0);
-
-  return {
-    totalWaves: waves.length,
-    totalTasks,
-    maxParallel,
-    sequential: waves.every((w) => w.taskIds.length === 1),
-  };
-}