chati-dev 4.3.0 → 4.4.0

package/src/tasks/loader.js

@@ -1,210 +0,0 @@
-/**
- * Task Loader — Parses task definition files (YAML frontmatter + markdown body).
- *
- * Task files live in chati.dev/tasks/{agent}-{action}.md and contain:
- * - YAML frontmatter: id, agent, trigger, phase, requires_input, parallelizable, outputs, handoff_to, autonomous_gate, criteria
- * - Markdown body: Step-by-step instructions for the agent
- */
-
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Parse a single task definition file.
- * @param {string} filePath - Absolute path to .md file with YAML frontmatter
- * @returns {{ loaded: boolean, task: object|null, error: string|null }}
- */
-export function loadTask(filePath) {
-  if (!existsSync(filePath)) {
-    return { loaded: false, task: null, error: `Task file not found: ${filePath}` };
-  }
-
-  try {
-    const raw = readFileSync(filePath, 'utf-8');
-    return parseTaskContent(raw, filePath);
-  } catch (err) {
-    return { loaded: false, task: null, error: `Failed to read ${filePath}: ${err.message}` };
-  }
-}
-
-/**
- * Parse task content string (YAML frontmatter + markdown body).
- * @param {string} content - Raw file content
- * @param {string} [source] - Source file path for error messages
- * @returns {{ loaded: boolean, task: object|null, error: string|null }}
- */
-export function parseTaskContent(content, source = 'unknown') {
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-
-  if (!frontmatterMatch) {
-    return { loaded: false, task: null, error: `No YAML frontmatter found in ${source}` };
-  }
-
-  const yamlStr = frontmatterMatch[1];
-  const body = frontmatterMatch[2].trim();
-
-  try {
-    const meta = parseSimpleYaml(yamlStr);
-
-    if (!meta.id) {
-      return { loaded: false, task: null, error: `Missing required field 'id' in ${source}` };
-    }
-    if (!meta.agent) {
-      return { loaded: false, task: null, error: `Missing required field 'agent' in ${source}` };
-    }
-
-    return {
-      loaded: true,
-      task: {
-        id: meta.id,
-        agent: meta.agent,
-        trigger: meta.trigger || 'orchestrator',
-        phase: meta.phase || 'plan',
-        requires_input: meta.requires_input === true || meta.requires_input === 'true',
-        parallelizable: meta.parallelizable === true || meta.parallelizable === 'true',
-        outputs: parseArray(meta.outputs),
-        handoff_to: meta.handoff_to || null,
-        autonomous_gate: meta.autonomous_gate !== false && meta.autonomous_gate !== 'false',
-        criteria: parseArray(meta.criteria),
-        instructions: body,
-        source,
-      },
-      error: null,
-    };
-  } catch (err) {
-    return { loaded: false, task: null, error: `YAML parse error in ${source}: ${err.message}` };
-  }
-}
-
-/**
- * Load all task definitions from a directory.
- * @param {string} tasksDir - Path to chati.dev/tasks/
- * @returns {{ tasks: Map<string, object>, errors: string[] }}
- */
-export function loadAllTasks(tasksDir) {
-  const tasks = new Map();
-  const errors = [];
-
-  if (!existsSync(tasksDir)) {
-    errors.push(`Tasks directory not found: ${tasksDir}`);
-    return { tasks, errors };
-  }
-
-  const files = readdirSync(tasksDir).filter(f => f.endsWith('.md'));
-
-  for (const file of files) {
-    const result = loadTask(join(tasksDir, file));
-    if (result.loaded) {
-      tasks.set(result.task.id, result.task);
-    } else {
-      errors.push(result.error);
-    }
-  }
-
-  return { tasks, errors };
-}
-
-/**
- * Get all tasks for a specific agent.
- * @param {Map<string, object>} taskMap - Map from loadAllTasks
- * @param {string} agentName - Agent name to filter by
- * @returns {object[]}
- */
-export function getAgentTasks(taskMap, agentName) {
-  const result = [];
-  for (const task of taskMap.values()) {
-    if (task.agent === agentName) {
-      result.push(task);
-    }
-  }
-  return result;
-}
-
-/**
- * Get a task's info summary (without instructions body).
- * @param {object} task - Task object from loadTask
- * @returns {object}
- */
-export function getTaskSummary(task) {
-  return {
-    id: task.id,
-    agent: task.agent,
-    phase: task.phase,
-    parallelizable: task.parallelizable,
-    outputs: task.outputs,
-    handoff_to: task.handoff_to,
-    criteria_count: task.criteria.length,
-  };
-}
-
-/**
- * Simple YAML parser for frontmatter (no external deps).
- * Handles key: value, key: [array], and key: true/false.
- */
-function parseSimpleYaml(str) {
-  const result = {};
-  let currentKey = null;
-  let currentArray = null;
-
-  for (const line of str.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-
-    // Array item under current key
-    if (trimmed.startsWith('- ') && currentKey && currentArray) {
-      currentArray.push(trimmed.slice(2).trim());
-      continue;
-    }
-
-    // Key: value pair
-    const kvMatch = trimmed.match(/^(\w[\w_-]*):\s*(.*)$/);
-    if (kvMatch) {
-      // Save previous array if any
-      if (currentKey && currentArray) {
-        result[currentKey] = currentArray;
-      }
-
-      const key = kvMatch[1];
-      const val = kvMatch[2].trim();
-
-      if (val === '') {
-        // Could be start of an array
-        currentKey = key;
-        currentArray = [];
-      } else if (val.startsWith('[') && val.endsWith(']')) {
-        // Inline array: [a, b, c]
-        result[key] = val.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
-        currentKey = null;
-        currentArray = null;
-      } else if (val === 'true') {
-        result[key] = true;
-        currentKey = null;
-        currentArray = null;
-      } else if (val === 'false') {
-        result[key] = false;
-        currentKey = null;
-        currentArray = null;
-      } else {
-        result[key] = val;
-        currentKey = null;
-        currentArray = null;
-      }
-    }
-  }
-
-  // Save trailing array
-  if (currentKey && currentArray) {
-    result[currentKey] = currentArray;
-  }
-
-  return result;
-}
-
-/**
- * Ensure a value is an array.
- */
-function parseArray(val) {
-  if (Array.isArray(val)) return val;
-  if (typeof val === 'string') return [val];
-  return [];
-}

package/src/tasks/router.js

@@ -1,182 +0,0 @@
-/**
- * Task Router — Maps orchestrator intents to the correct task definition.
- *
- * The router is used internally by the orchestrator to determine
- * which task an agent should execute based on:
- * - Current pipeline position
- * - Agent state
- * - User intent signals
- */
-
-import { loadAllTasks, getAgentTasks } from './loader.js';
-
-/**
- * Task Router instance.
- * Holds the loaded task registry and provides routing methods.
- */
-export class TaskRouter {
-  /**
-   * @param {string} tasksDir - Path to chati.dev/tasks/
-   */
-  constructor(tasksDir) {
-    this.tasksDir = tasksDir;
-    this.taskMap = new Map();
-    this.errors = [];
-    this.loaded = false;
-  }
-
-  /**
-   * Initialize the router by loading all task definitions.
-   * @returns {this}
-   */
-  load() {
-    const result = loadAllTasks(this.tasksDir);
-    this.taskMap = result.tasks;
-    this.errors = result.errors;
-    this.loaded = true;
-    return this;
-  }
-
-  /**
-   * Route to the correct task for an agent at a given pipeline position.
-   *
-   * Routing priority:
-   * 1. Exact task ID match (if provided)
-   * 2. Agent's consolidate task (if pipeline position = consolidate)
-   * 3. Agent's first non-consolidate task (default entry point)
-   *
-   * @param {object} intent
-   * @param {string} intent.agent - Target agent name
-   * @param {string} [intent.taskId] - Explicit task ID (highest priority)
-   * @param {string} [intent.action] - Action keyword (e.g., 'consolidate', 'extract')
-   * @param {string} [intent.phase] - Pipeline phase filter
-   * @returns {{ found: boolean, task: object|null, reason: string }}
-   */
-  route(intent) {
-    if (!this.loaded) {
-      return { found: false, task: null, reason: 'Router not loaded. Call load() first.' };
-    }
-
-    if (!intent || !intent.agent) {
-      return { found: false, task: null, reason: 'No agent specified in routing intent.' };
-    }
-
-    // 1. Exact task ID match
-    if (intent.taskId) {
-      const task = this.taskMap.get(intent.taskId);
-      if (task) {
-        return { found: true, task, reason: `Exact match: ${intent.taskId}` };
-      }
-      return { found: false, task: null, reason: `Task ID '${intent.taskId}' not found in registry.` };
-    }
-
-    // Get all tasks for this agent
-    const agentTasks = getAgentTasks(this.taskMap, intent.agent);
-    if (agentTasks.length === 0) {
-      return { found: false, task: null, reason: `No tasks registered for agent '${intent.agent}'.` };
-    }
-
-    // Filter by phase if provided
-    let candidates = agentTasks;
-    if (intent.phase) {
-      const phaseFiltered = agentTasks.filter(t => t.phase === intent.phase);
-      if (phaseFiltered.length > 0) {
-        candidates = phaseFiltered;
-      }
-    }
-
-    // 2. Action keyword match
-    if (intent.action) {
-      const actionTask = candidates.find(t =>
-        t.id.includes(intent.action) || t.id.endsWith(`-${intent.action}`)
-      );
-      if (actionTask) {
-        return { found: true, task: actionTask, reason: `Action match: ${intent.action}` };
-      }
-    }
-
-    // 3. Consolidate task (if action is consolidate or implied)
-    if (intent.action === 'consolidate') {
-      const consolidateTask = candidates.find(t => t.id.endsWith('-consolidate'));
-      if (consolidateTask) {
-        return { found: true, task: consolidateTask, reason: 'Consolidate task selected.' };
-      }
-    }
-
-    // 4. Default: first non-consolidate task (entry point)
-    const entryTask = candidates.find(t => !t.id.endsWith('-consolidate')) || candidates[0];
-    return { found: true, task: entryTask, reason: `Default entry: ${entryTask.id}` };
-  }
-
-  /**
-   * Get the next task in an agent's task sequence.
-   * Uses the handoff_to field to determine chaining.
-   *
-   * @param {string} currentTaskId - Currently executing task ID
-   * @returns {{ found: boolean, task: object|null, reason: string }}
-   */
-  getNextTask(currentTaskId) {
-    const current = this.taskMap.get(currentTaskId);
-    if (!current) {
-      return { found: false, task: null, reason: `Current task '${currentTaskId}' not found.` };
-    }
-
-    // If handoff_to is an agent name, it means we switch agents (orchestrator handles this)
-    // If handoff_to is a task ID within the same agent, it's internal chaining
-    if (!current.handoff_to) {
-      return { found: false, task: null, reason: 'No handoff defined for this task.' };
-    }
-
-    // Check if handoff_to is a task ID
-    const nextTask = this.taskMap.get(current.handoff_to);
-    if (nextTask) {
-      return { found: true, task: nextTask, reason: `Internal chain: ${current.handoff_to}` };
-    }
-
-    // Otherwise it's an agent-level handoff (handled by orchestrator)
-    return {
-      found: false,
-      task: null,
-      reason: `Agent handoff to '${current.handoff_to}'. Orchestrator handles inter-agent routing.`,
-    };
-  }
-
-  /**
-   * Get all parallelizable tasks for a given agent.
-   * @param {string} agentName
-   * @returns {object[]}
-   */
-  getParallelTasks(agentName) {
-    return getAgentTasks(this.taskMap, agentName).filter(t => t.parallelizable);
-  }
-
-  /**
-   * Get routing statistics.
-   * @returns {{ totalTasks: number, byAgent: object, byPhase: object, errors: number }}
-   */
-  getStats() {
-    const byAgent = {};
-    const byPhase = {};
-
-    for (const task of this.taskMap.values()) {
-      byAgent[task.agent] = (byAgent[task.agent] || 0) + 1;
-      byPhase[task.phase] = (byPhase[task.phase] || 0) + 1;
-    }
-
-    return {
-      totalTasks: this.taskMap.size,
-      byAgent,
-      byPhase,
-      errors: this.errors.length,
-    };
-  }
-}
-
-/**
- * Create and load a TaskRouter instance.
- * @param {string} tasksDir - Path to chati.dev/tasks/
- * @returns {TaskRouter}
- */
-export function createRouter(tasksDir) {
-  return new TaskRouter(tasksDir).load();
-}

package/src/utils/event-bus.js

@@ -1,126 +0,0 @@
-/**
- * @fileoverview Singleton event bus for the chati.dev framework.
- *
- * Provides a centralized EventEmitter for observing state changes
- * across subsystems (build-loop, spawner, pipeline, safety-net).
- */
-
-/**
- * @deprecated Not currently imported by any production module.
- * Retained for potential future integration. Review for removal or integration by v5.0.
- */
-
-import { EventEmitter } from 'node:events';
-
-// ---------------------------------------------------------------------------
-// Event Names
-// ---------------------------------------------------------------------------
-
-/**
- * All framework event names, organized by subsystem.
- */
-export const EVENTS = {
-  // Build loop
-  BUILD_STARTED: 'build:started',
-  BUILD_COMPLETED: 'build:completed',
-  BUILD_FAILED: 'build:failed',
-  TASK_STARTED: 'build:task:started',
-  TASK_COMPLETED: 'build:task:completed',
-  TASK_FAILED: 'build:task:failed',
-  TASK_EXHAUSTED: 'build:task:exhausted',
-
-  // Spawner
-  TERMINAL_SPAWNED: 'terminal:spawned',
-  TERMINAL_EXITED: 'terminal:exited',
-  TERMINAL_KILLED: 'terminal:killed',
-
-  // Pipeline
-  PHASE_ADVANCED: 'pipeline:phase:advanced',
-  AGENT_COMPLETED: 'pipeline:agent:completed',
-  QA_GATE_PASSED: 'pipeline:qa:passed',
-  QA_GATE_FAILED: 'pipeline:qa:failed',
-
-  // Safety
-  SAFETY_TRIGGERED: 'safety:triggered',
-
-  // Health
-  HEALTH_CHECK_COMPLETED: 'health:completed',
-
-  // Escalation
-  ESCALATION_TRIGGERED: 'escalation:triggered',
-  ESCALATION_PAUSED: 'escalation:paused',
-};
-
-// ---------------------------------------------------------------------------
-// Bus Instance
-// ---------------------------------------------------------------------------
-
-const bus = new EventEmitter();
-bus.setMaxListeners(50);
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Emit an event with data. Automatically adds a timestamp.
- *
- * @param {string} event - Event name from EVENTS
- * @param {object} [data={}] - Event payload
- */
-export function emit(event, data = {}) {
-  bus.emit(event, { ...data, timestamp: Date.now() });
-}
-
-/**
- * Subscribe to an event.
- *
- * @param {string} event - Event name
- * @param {function} handler - Event handler
- */
-export function on(event, handler) {
-  bus.on(event, handler);
-}
-
-/**
- * Subscribe to an event once.
- *
- * @param {string} event - Event name
- * @param {function} handler - Event handler
- */
-export function once(event, handler) {
-  bus.once(event, handler);
-}
-
-/**
- * Unsubscribe from an event.
- *
- * @param {string} event - Event name
- * @param {function} handler - Event handler to remove
- */
-export function off(event, handler) {
-  bus.off(event, handler);
-}
-
-/**
- * Remove all listeners for an event, or all events if no event specified.
- *
- * @param {string} [event] - Event name (optional)
- */
-export function removeAllListeners(event) {
-  if (event) {
-    bus.removeAllListeners(event);
-  } else {
-    bus.removeAllListeners();
-  }
-}
-
-/**
- * Get the count of listeners for an event.
- *
- * @param {string} event - Event name
- * @returns {number}
- */
-export function listenerCount(event) {
-  return bus.listenerCount(event);
-}