chati-dev 1.3.3 → 2.0.1

package/src/orchestrator/pipeline-manager.js

@@ -0,0 +1,492 @@
+/**
+ * @fileoverview Pipeline lifecycle management.
+ * Manages the complete pipeline state and transitions.
+ */
+
+import { AGENT_PIPELINE, getNextAgent } from './agent-selector.js';
+
+/**
+ * Pipeline phases in order.
+ */
+export const PIPELINE_PHASES = ['clarity', 'build', 'deploy'];
+
+/**
+ * Agent status values.
+ */
+export const AGENT_STATUS = {
+  PENDING: 'pending',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  SKIPPED: 'skipped',
+  NEEDS_REVALIDATION: 'needs_revalidation',
+  FAILED: 'failed',
+};
+
+/**
+ * Required QA score for phase transitions.
+ */
+const QA_PLANNING_THRESHOLD = 95;
+const QA_IMPLEMENTATION_THRESHOLD = 90;
+
+/**
+ * Initialize a new pipeline for a project.
+ *
+ * @param {object} options - { isGreenfield, mode }
+ * @returns {object} Pipeline state
+ */
+export function initPipeline(options = {}) {
+  const { isGreenfield = true, mode = 'clarity' } = options;
+
+  const agents = {};
+  for (const agentDef of AGENT_PIPELINE) {
+    // Skip the WU agent that doesn't apply
+    if (agentDef.group === 'wu') {
+      const shouldInclude = isGreenfield
+        ? agentDef.name === 'greenfield-wu'
+        : agentDef.name === 'brownfield-wu';
+      if (!shouldInclude) {
+        continue;
+      }
+    }
+
+    agents[agentDef.name] = {
+      status: AGENT_STATUS.PENDING,
+      score: null,
+      startedAt: null,
+      completedAt: null,
+    };
+  }
+
+  return {
+    phase: mode,
+    isGreenfield,
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    agents,
+    completedAgents: [],
+    currentAgent: null,
+    modeTransitions: [],
+    history: [],
+  };
+}
+
+/**
+ * Advance the pipeline after an agent completes.
+ *
+ * @param {object} pipelineState - Current state
+ * @param {string} completedAgent - Agent that just finished
+ * @param {object} [results] - Agent results (score, outputs)
+ * @returns {{ state: object, nextAction: string, nextAgent: string|null, needsModeSwitch: boolean }}
+ */
+export function advancePipeline(pipelineState, completedAgent, results = {}) {
+  const newState = { ...pipelineState };
+
+  // Update completed agent status
+  if (!newState.agents[completedAgent]) {
+    throw new Error(`Unknown agent: ${completedAgent}`);
+  }
+
+  newState.agents[completedAgent] = {
+    ...newState.agents[completedAgent],
+    status: AGENT_STATUS.COMPLETED,
+    score: results.score || null,
+    completedAt: new Date().toISOString(),
+  };
+
+  // Add to completed list if not already there
+  if (!newState.completedAgents.includes(completedAgent)) {
+    newState.completedAgents.push(completedAgent);
+  }
+
+  // Add to history
+  newState.history.push({
+    agent: completedAgent,
+    action: 'completed',
+    timestamp: new Date().toISOString(),
+    score: results.score || null,
+  });
+
+  // Special handling for QA agents - check if they meet thresholds
+  const isQAAgent = completedAgent === 'qa-planning' || completedAgent === 'qa-implementation';
+  if (isQAAgent) {
+    const transitionCheck = checkPhaseTransition(newState);
+
+    if (transitionCheck.canAdvance) {
+      // QA passed - advance to next phase
+      const currentPhaseIndex = PIPELINE_PHASES.indexOf(newState.phase);
+      if (currentPhaseIndex < PIPELINE_PHASES.length - 1) {
+        const nextPhase = PIPELINE_PHASES[currentPhaseIndex + 1];
+
+        newState.modeTransitions.push({
+          from: newState.phase,
+          to: nextPhase,
+          trigger: 'autonomous',
+          timestamp: new Date().toISOString(),
+          reason: transitionCheck.reason,
+        });
+
+        newState.phase = nextPhase;
+
+        return {
+          state: newState,
+          nextAction: 'advance_phase',
+          nextAgent: getFirstAgentInPhase(newState, nextPhase),
+          needsModeSwitch: true,
+        };
+      }
+
+      // Pipeline complete
+      newState.completedAt = new Date().toISOString();
+      return {
+        state: newState,
+        nextAction: 'complete',
+        nextAgent: null,
+        needsModeSwitch: false,
+      };
+    } else {
+      // QA failed - wait for issues to be fixed
+      return {
+        state: newState,
+        nextAction: 'wait',
+        nextAgent: null,
+        needsModeSwitch: false,
+      };
+    }
+  }
+
+  // Check if phase transition is possible for non-QA agents
+  const transitionCheck = checkPhaseTransition(newState);
+
+  if (transitionCheck.canAdvance) {
+    // Advance to next phase
+    const currentPhaseIndex = PIPELINE_PHASES.indexOf(newState.phase);
+    if (currentPhaseIndex < PIPELINE_PHASES.length - 1) {
+      const nextPhase = PIPELINE_PHASES[currentPhaseIndex + 1];
+
+      newState.modeTransitions.push({
+        from: newState.phase,
+        to: nextPhase,
+        trigger: 'autonomous',
+        timestamp: new Date().toISOString(),
+        reason: transitionCheck.reason,
+      });
+
+      newState.phase = nextPhase;
+
+      return {
+        state: newState,
+        nextAction: 'advance_phase',
+        nextAgent: getFirstAgentInPhase(newState, nextPhase),
+        needsModeSwitch: true,
+      };
+    }
+
+    // Pipeline complete
+    newState.completedAt = new Date().toISOString();
+    return {
+      state: newState,
+      nextAction: 'complete',
+      nextAgent: null,
+      needsModeSwitch: false,
+    };
+  }
+
+  // Continue in current phase
+  const nextInfo = getNextAgent(completedAgent, newState.completedAgents);
+
+  if (nextInfo.next) {
+    newState.currentAgent = nextInfo.next;
+    if (newState.agents[nextInfo.next]) {
+      newState.agents[nextInfo.next].status = AGENT_STATUS.IN_PROGRESS;
+      newState.agents[nextInfo.next].startedAt = new Date().toISOString();
+    }
+
+    return {
+      state: newState,
+      nextAction: 'continue',
+      nextAgent: nextInfo.next,
+      needsModeSwitch: false,
+    };
+  }
+
+  // No next agent but can't advance phase - stuck
+  return {
+    state: newState,
+    nextAction: 'wait',
+    nextAgent: null,
+    needsModeSwitch: false,
+  };
+}
+
+/**
+ * Get first agent in a phase.
+ *
+ * @param {object} state - Pipeline state
+ * @param {string} phase - Target phase
+ * @returns {string|null}
+ */
+function getFirstAgentInPhase(state, phase) {
+  for (const agentDef of AGENT_PIPELINE) {
+    if (agentDef.phase !== phase) {
+      continue;
+    }
+
+    // Skip WU fork that doesn't apply
+    if (agentDef.group === 'wu') {
+      const targetAgent = state.isGreenfield ? 'greenfield-wu' : 'brownfield-wu';
+      if (agentDef.name !== targetAgent) {
+        continue;
+      }
+    }
+
+    if (state.agents[agentDef.name]) {
+      return agentDef.name;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if pipeline can transition to next phase.
+ *
+ * @param {object} pipelineState
+ * @returns {{ canAdvance: boolean, reason: string, requiredScore: number|null }}
+ */
+export function checkPhaseTransition(pipelineState) {
+  const { phase, agents } = pipelineState;
+
+  // Check based on current phase
+  if (phase === 'clarity') {
+    // Need QA-Planning to be completed with score >= 95
+    const qaPlanning = agents['qa-planning'];
+    if (!qaPlanning) {
+      return {
+        canAdvance: false,
+        reason: 'QA-Planning agent not in pipeline',
+        requiredScore: null,
+      };
+    }
+
+    if (qaPlanning.status !== AGENT_STATUS.COMPLETED) {
+      return {
+        canAdvance: false,
+        reason: 'QA-Planning not yet completed',
+        requiredScore: QA_PLANNING_THRESHOLD,
+      };
+    }
+
+    if (qaPlanning.score === null || qaPlanning.score < QA_PLANNING_THRESHOLD) {
+      return {
+        canAdvance: false,
+        reason: `QA-Planning score ${qaPlanning.score || 0} below threshold ${QA_PLANNING_THRESHOLD}`,
+        requiredScore: QA_PLANNING_THRESHOLD,
+      };
+    }
+
+    return {
+      canAdvance: true,
+      reason: `QA-Planning approved with score ${qaPlanning.score}`,
+      requiredScore: null,
+    };
+  }
+
+  if (phase === 'build') {
+    // Need dev and QA-Implementation completed
+    const dev = agents['dev'];
+    const qaImpl = agents['qa-implementation'];
+
+    if (!dev || !qaImpl) {
+      return {
+        canAdvance: false,
+        reason: 'Build agents not in pipeline',
+        requiredScore: null,
+      };
+    }
+
+    if (dev.status !== AGENT_STATUS.COMPLETED) {
+      return {
+        canAdvance: false,
+        reason: 'Dev agent not yet completed',
+        requiredScore: null,
+      };
+    }
+
+    if (qaImpl.status !== AGENT_STATUS.COMPLETED) {
+      return {
+        canAdvance: false,
+        reason: 'QA-Implementation not yet completed',
+        requiredScore: QA_IMPLEMENTATION_THRESHOLD,
+      };
+    }
+
+    if (qaImpl.score === null || qaImpl.score < QA_IMPLEMENTATION_THRESHOLD) {
+      return {
+        canAdvance: false,
+        reason: `QA-Implementation score ${qaImpl.score || 0} below threshold ${QA_IMPLEMENTATION_THRESHOLD}`,
+        requiredScore: QA_IMPLEMENTATION_THRESHOLD,
+      };
+    }
+
+    return {
+      canAdvance: true,
+      reason: `QA-Implementation approved with score ${qaImpl.score}`,
+      requiredScore: null,
+    };
+  }
+
+  if (phase === 'deploy') {
+    // Deploy is final phase
+    const devops = agents['devops'];
+    if (!devops) {
+      return {
+        canAdvance: false,
+        reason: 'DevOps agent not in pipeline',
+        requiredScore: null,
+      };
+    }
+
+    if (devops.status === AGENT_STATUS.COMPLETED) {
+      return {
+        canAdvance: true,
+        reason: 'DevOps completed - pipeline finished',
+        requiredScore: null,
+      };
+    }
+
+    return {
+      canAdvance: false,
+      reason: 'DevOps not yet completed',
+      requiredScore: null,
+    };
+  }
+
+  return {
+    canAdvance: false,
+    reason: `Unknown phase: ${phase}`,
+    requiredScore: null,
+  };
+}
+
+/**
+ * Get pipeline progress summary.
+ *
+ * @param {object} pipelineState
+ * @returns {{ phase: string, progress: number, completedAgents: string[], currentAgent: string|null, nextAgent: string|null }}
+ */
+export function getPipelineProgress(pipelineState) {
+  const { phase, agents, completedAgents, currentAgent } = pipelineState;
+
+  // Calculate progress percentage
+  const totalAgents = Object.keys(agents).length;
+  const completed = completedAgents.length;
+  const progress = totalAgents > 0 ? (completed / totalAgents) * 100 : 0;
+
+  // Find next agent
+  let nextAgent = null;
+  if (currentAgent) {
+    const nextInfo = getNextAgent(currentAgent, completedAgents);
+    nextAgent = nextInfo.next;
+  }
+
+  return {
+    phase,
+    progress: Math.round(progress),
+    completedAgents,
+    currentAgent,
+    nextAgent,
+  };
+}
+
+/**
+ * Reset pipeline to a specific agent (for rollback/deviation).
+ *
+ * @param {object} pipelineState
+ * @param {string} targetAgent
+ * @returns {object} Updated pipeline state
+ */
+export function resetPipelineTo(pipelineState, targetAgent) {
+  const newState = { ...pipelineState };
+
+  // Find target agent in pipeline
+  const targetDef = AGENT_PIPELINE.find((a) => a.name === targetAgent);
+  if (!targetDef) {
+    throw new Error(`Unknown target agent: ${targetAgent}`);
+  }
+
+  // Reset phase to target agent's phase
+  newState.phase = targetDef.phase;
+
+  // Find all agents after target in pipeline
+  const targetIndex = AGENT_PIPELINE.findIndex((a) => a.name === targetAgent);
+  const agentsToReset = AGENT_PIPELINE.slice(targetIndex).map((a) => a.name);
+
+  // Reset their status
+  for (const agentName of agentsToReset) {
+    if (newState.agents[agentName]) {
+      newState.agents[agentName] = {
+        status: AGENT_STATUS.PENDING,
+        score: null,
+        startedAt: null,
+        completedAt: null,
+      };
+    }
+  }
+
+  // Update completed agents list
+  newState.completedAgents = newState.completedAgents.filter(
+    (name) => !agentsToReset.includes(name)
+  );
+
+  // Set current agent
+  newState.currentAgent = targetAgent;
+  if (newState.agents[targetAgent]) {
+    newState.agents[targetAgent].status = AGENT_STATUS.IN_PROGRESS;
+    newState.agents[targetAgent].startedAt = new Date().toISOString();
+  }
+
+  // Add to history
+  newState.history.push({
+    agent: targetAgent,
+    action: 'reset_to',
+    timestamp: new Date().toISOString(),
+    reason: 'Pipeline rollback',
+  });
+
+  return newState;
+}
+
+/**
+ * Check if pipeline is complete.
+ *
+ * @param {object} pipelineState
+ * @returns {boolean}
+ */
+export function isPipelineComplete(pipelineState) {
+  return pipelineState.completedAt !== null;
+}
+
+/**
+ * Mark an agent as in progress.
+ *
+ * @param {object} pipelineState
+ * @param {string} agentName
+ * @returns {object} Updated pipeline state
+ */
+export function markAgentInProgress(pipelineState, agentName) {
+  const newState = { ...pipelineState };
+
+  if (!newState.agents[agentName]) {
+    throw new Error(`Unknown agent: ${agentName}`);
+  }
+
+  newState.agents[agentName] = {
+    ...newState.agents[agentName],
+    status: AGENT_STATUS.IN_PROGRESS,
+    startedAt: new Date().toISOString(),
+  };
+
+  newState.currentAgent = agentName;
+
+  return newState;
+}

package/src/orchestrator/pipeline-state.js

@@ -0,0 +1,223 @@
+/**
+ * @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 || 'clarity',
+      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 };
+  }
+}