pixelcrew 0.2.2 → 0.2.6

package/src/core/orchestrator.js

@@ -0,0 +1,234 @@
+/**
+ * PIXEL CREW — Decoupled Universal Core Orchestrator
+ * 
+ * Orchestrates multi-agent pipelines, task graph scheduling, provider routing,
+ * and real-time state telemetry completely decoupled from specific IDEs.
+ */
+
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { TaskGraph } from './task-graph.js';
+import { Scheduler } from './scheduler.js';
+import { AgentRuntime } from './agent-runtime.js';
+import { EventBus } from './event-bus.js';
+import { AGENT_STATES, AGENT_EXPRESSIONS, ORCHESTRATOR_EXPRESSIONS } from '../protocol/agent.js';
+import { EVENT_TYPES } from '../protocol/event.js';
+import { TASK_STATUS } from '../protocol/task.js';
+
+export class CoreOrchestrator extends EventEmitter {
+  constructor(rootDir = process.cwd(), options = {}) {
+    super();
+    this.rootDir = rootDir;
+    this.options = options;
+
+    // Filesystem compatibility paths (.pixel-crew primary, .pixel-agents legacy fallback)
+    this.crewDir = path.join(rootDir, '.pixel-crew');
+    this.agentsDir = path.join(rootDir, '.pixel-agents');
+    this.activeDir = this.crewDir;
+
+    this.eventBus = new EventBus();
+    this.agentRuntime = new AgentRuntime({ eventBus: this.eventBus });
+    this.scheduler = new Scheduler({
+      maxConcurrent: options.maxConcurrent || 4,
+      agentRuntime: this.agentRuntime
+    });
+
+    this.providerRegistry = null;
+    this.skillRegistry = null;
+    this.config = null;
+    this.state = null;
+    this.activeTaskGraph = null;
+    this.activeSprintAbort = null;
+
+    // Forward events from eventBus to orchestrator listeners
+    this.eventBus.on('event', (evt) => {
+      this.emit('event', evt);
+      this.emit('agent_event', evt);
+      this.syncStateFromEvent(evt);
+    });
+  }
+
+  setProviderRegistry(registry) {
+    this.providerRegistry = registry;
+    this.scheduler.setProviderRegistry(registry);
+  }
+
+  setSkillRegistry(registry) {
+    this.skillRegistry = registry;
+  }
+
+  async initialize() {
+    // Check if .pixel-crew exists, fallback to .pixel-agents
+    let hasCrewDir = false;
+    try {
+      await fs.access(this.crewDir);
+      hasCrewDir = true;
+      this.activeDir = this.crewDir;
+    } catch {
+      try {
+        await fs.access(this.agentsDir);
+        this.activeDir = this.agentsDir;
+      } catch {
+        this.activeDir = this.crewDir;
+      }
+    }
+
+    const configPath = path.join(this.activeDir, 'config.json');
+    const statePath = path.join(this.activeDir, 'state.json');
+    const eventsPath = path.join(this.activeDir, 'events.jsonl');
+
+    // Register log paths on event bus
+    this.eventBus.addLogFilePath(eventsPath);
+    if (this.activeDir !== this.agentsDir) {
+      // Also register legacy path if .pixel-agents exists
+      try {
+        await fs.access(this.agentsDir);
+        this.eventBus.addLogFilePath(path.join(this.agentsDir, 'events.jsonl'));
+      } catch {}
+    }
+
+    // Load Config
+    try {
+      const raw = await fs.readFile(configPath, 'utf-8');
+      this.config = JSON.parse(raw);
+    } catch {
+      this.config = {
+        project: path.basename(this.rootDir),
+        orchestrator: { enabled: true, maxConcurrentAgents: 4, runtimeStrategy: 'auto' },
+        agents: {},
+        dashboard: { enabled: true, port: 4747 }
+      };
+    }
+
+    // Load State
+    try {
+      const raw = await fs.readFile(statePath, 'utf-8');
+      this.state = JSON.parse(raw);
+    } catch {
+      this.state = {
+        status: 'READY',
+        activeTask: 'Waiting for tasks',
+        startedAt: null,
+        completedAt: null,
+        orchestrator: { state: AGENT_STATES.IDLE, expression: ORCHESTRATOR_EXPRESSIONS.IDLE, activeSubtasks: 0, totalSubtasks: 0, progress: 0 },
+        agents: {}
+      };
+    }
+
+    // Load Events
+    await this.eventBus.loadFromDisk(eventsPath);
+
+    return this;
+  }
+
+  getState() {
+    return this.state;
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  getEvents() {
+    return this.eventBus.getHistory();
+  }
+
+  async emitEvent(eventData) {
+    return await this.eventBus.emitEvent(eventData);
+  }
+
+  syncStateFromEvent(event) {
+    if (!this.state) return;
+
+    if (event.type === EVENT_TYPES.ORCHESTRATION_STARTED) {
+      this.state.status = 'RUNNING';
+      this.state.activeTask = event.taskName || event.message;
+      this.state.startedAt = event.timestamp;
+      this.state.completedAt = null;
+      this.state.orchestrator = {
+        state: AGENT_STATES.WORKING,
+        expression: ORCHESTRATOR_EXPRESSIONS.COORDINATING,
+        progress: 5
+      };
+    } else if (event.type === EVENT_TYPES.ORCHESTRATION_COMPLETED) {
+      this.state.status = 'COMPLETED';
+      this.state.completedAt = event.timestamp;
+      this.state.orchestrator = {
+        state: AGENT_STATES.COMPLETED,
+        expression: ORCHESTRATOR_EXPRESSIONS.COMPLETED,
+        progress: 100
+      };
+    } else if (event.type === EVENT_TYPES.AGENT_STARTED) {
+      if (event.agent && this.state.agents) {
+        this.state.agents[event.agent] = {
+          state: AGENT_STATES.WORKING,
+          expression: AGENT_EXPRESSIONS.WORKING,
+          currentTask: event.taskName || event.message,
+          provider: event.provider
+        };
+      }
+    } else if (event.type === EVENT_TYPES.TASK_COMPLETED) {
+      if (event.agent && this.state.agents) {
+        this.state.agents[event.agent] = {
+          state: AGENT_STATES.COMPLETED,
+          expression: AGENT_EXPRESSIONS.COMPLETED,
+          currentTask: `Completed: ${event.taskName || ''}`,
+          provider: event.provider
+        };
+      }
+    }
+
+    this.emit('state_change', { state: this.state });
+  }
+
+  /**
+   * Dispatches and executes a TaskGraph
+   */
+  async executeTaskGraph(taskGraph, options = {}) {
+    this.activeTaskGraph = taskGraph;
+
+    await this.emitEvent({
+      agent: 'orchestrator',
+      type: EVENT_TYPES.ORCHESTRATION_STARTED,
+      taskName: options.title || 'Multi-Agent Task Sprint',
+      message: `Orchestrator dispatching DAG task graph (${taskGraph.tasks.size} tasks)`
+    });
+
+    try {
+      const result = await this.scheduler.execute(taskGraph, {
+        strategy: options.strategy || this.config?.orchestrator?.runtimeStrategy || 'auto',
+        ...options
+      });
+
+      await this.emitEvent({
+        agent: 'orchestrator',
+        type: EVENT_TYPES.ORCHESTRATION_COMPLETED,
+        taskName: options.title || 'Multi-Agent Task Sprint',
+        message: `Orchestration completed successfully (${result.completed}/${result.total} tasks resolved)`
+      });
+
+      return result;
+    } catch (err) {
+      await this.emitEvent({
+        agent: 'orchestrator',
+        type: EVENT_TYPES.ORCHESTRATION_FAILED,
+        taskName: options.title || 'Multi-Agent Task Sprint',
+        message: `Orchestration sprint failed: ${err.message}`,
+        data: { error: err.message }
+      });
+      throw err;
+    } finally {
+      this.activeTaskGraph = null;
+    }
+  }
+
+  cancelActiveExecution() {
+    this.scheduler.cancel();
+    if (this.state) {
+      this.state.status = 'READY';
+      this.state.orchestrator.state = AGENT_STATES.IDLE;
+      this.state.orchestrator.expression = ORCHESTRATOR_EXPRESSIONS.IDLE;
+    }
+  }
+}

package/src/core/scheduler.js

@@ -0,0 +1,124 @@
+/**
+ * PIXEL CREW — Core Scheduler & Concurrency Dispatcher
+ * 
+ * Schedules task batches from a TaskGraph to Worker Slots respecting dependencies,
+ * concurrency limits, and provider routing.
+ */
+
+import { EventEmitter } from 'node:events';
+import { TASK_STATUS } from '../protocol/task.js';
+
+export class Scheduler extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.maxConcurrent = options.maxConcurrent || 4;
+    this.agentRuntime = options.agentRuntime || null;
+    this.providerRegistry = options.providerRegistry || null;
+    this.abortController = null;
+    this.activeWorkers = new Set();
+  }
+
+  setAgentRuntime(runtime) {
+    this.agentRuntime = runtime;
+  }
+
+  setProviderRegistry(registry) {
+    this.providerRegistry = registry;
+  }
+
+  /**
+   * Executes a TaskGraph until completion or error
+   */
+  async execute(taskGraph, options = {}) {
+    this.abortController = new AbortController();
+    const runtimeStrategy = options.strategy || 'auto';
+    const handler = options.executeTaskHandler || null;
+
+    if (taskGraph.hasCycle()) {
+      throw new Error('Deadlock detected in TaskGraph: Cyclic dependencies present');
+    }
+
+    const runningPromises = new Map();
+
+    while (!taskGraph.isCompleted() && !taskGraph.hasFailed()) {
+      if (this.abortController.signal.aborted) {
+        throw new Error('Scheduler execution aborted');
+      }
+
+      const readyTasks = taskGraph.getReadyTasks();
+
+      // If no tasks ready and none running, graph is stuck
+      if (readyTasks.length === 0 && runningPromises.size === 0) {
+        if (!taskGraph.isCompleted()) {
+          throw new Error('TaskGraph stalled: unresolvable dependencies or missing prerequisite tasks');
+        }
+        break;
+      }
+
+      // Fill available concurrency slots
+      const availableSlots = this.maxConcurrent - runningPromises.size;
+      const tasksToDispatch = readyTasks.slice(0, Math.max(0, availableSlots));
+
+      for (const task of tasksToDispatch) {
+        taskGraph.markRunning(task.id);
+
+        const taskPromise = (async () => {
+          let adapter = null;
+          if (this.providerRegistry) {
+            adapter = await this.providerRegistry.getBestAgent(task, runtimeStrategy);
+          }
+
+          if (this.agentRuntime) {
+            return await this.agentRuntime.executeTask(task, adapter, {
+              abortController: this.abortController,
+              executeTaskHandler: handler,
+              ...options
+            });
+          } else if (handler) {
+            return await handler(task);
+          } else {
+            await new Promise(r => setTimeout(r, 200));
+            return { success: true };
+          }
+        })()
+          .then((result) => {
+            taskGraph.markCompleted(task.id, result);
+            this.emit('task_completed', { task, result });
+          })
+          .catch((err) => {
+            taskGraph.markFailed(task.id, err);
+            this.emit('task_failed', { task, error: err });
+            throw err;
+          })
+          .finally(() => {
+            runningPromises.delete(task.id);
+          });
+
+        runningPromises.set(task.id, taskPromise);
+      }
+
+      if (runningPromises.size > 0) {
+        // Wait for at least one running task to finish before next loop iteration
+        await Promise.race(runningPromises.values());
+      }
+    }
+
+    // Wait for any remaining tasks to settle
+    if (runningPromises.size > 0) {
+      await Promise.all(runningPromises.values());
+    }
+
+    return {
+      success: !taskGraph.hasFailed(),
+      completed: taskGraph.completedTaskIds.size,
+      total: taskGraph.tasks.size,
+      tasks: taskGraph.getAllTasks()
+    };
+  }
+
+  cancel() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+}

package/src/core/task-graph.js

@@ -0,0 +1,185 @@
+/**
+ * PIXEL CREW — Dynamic Directed Acyclic Graph (DAG) Task Engine
+ * 
+ * Manages task graph construction, topological sorting, cycle detection,
+ * and parallel dependency resolution.
+ */
+
+import { createTask, TASK_STATUS, validateTask } from '../protocol/task.js';
+
+export class TaskGraph {
+  constructor(tasks = []) {
+    this.tasks = new Map();
+    this.completedTaskIds = new Set();
+    this.runningTaskIds = new Set();
+    this.failedTaskIds = new Set();
+
+    for (const t of tasks) {
+      this.addTask(t);
+    }
+  }
+
+  /**
+   * Adds a task to the graph
+   */
+  addTask(taskInput) {
+    const task = taskInput.id && taskInput.title ? taskInput : createTask(taskInput);
+    validateTask(task);
+    this.tasks.set(task.id, task);
+    if (task.status === TASK_STATUS.COMPLETED) {
+      this.completedTaskIds.add(task.id);
+    } else if (task.status === TASK_STATUS.RUNNING) {
+      this.runningTaskIds.add(task.id);
+    } else if (task.status === TASK_STATUS.FAILED) {
+      this.failedTaskIds.add(task.id);
+    }
+    return task;
+  }
+
+  getTask(id) {
+    return this.tasks.get(id) || null;
+  }
+
+  getAllTasks() {
+    return Array.from(this.tasks.values());
+  }
+
+  /**
+   * Detects cycles in the task graph using DFS
+   */
+  hasCycle() {
+    const visited = new Set();
+    const recursionStack = new Set();
+
+    const dfs = (taskId) => {
+      visited.add(taskId);
+      recursionStack.add(taskId);
+
+      const task = this.tasks.get(taskId);
+      if (task && Array.isArray(task.dependencies)) {
+        for (const depId of task.dependencies) {
+          if (!this.tasks.has(depId)) {
+            // Unresolved external dependency
+            continue;
+          }
+          if (!visited.has(depId)) {
+            if (dfs(depId)) return true;
+          } else if (recursionStack.has(depId)) {
+            return true;
+          }
+        }
+      }
+
+      recursionStack.delete(taskId);
+      return false;
+    };
+
+    for (const taskId of this.tasks.keys()) {
+      if (!visited.has(taskId)) {
+        if (dfs(taskId)) return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns topological ordering of tasks
+   */
+  getTopologicalOrder() {
+    if (this.hasCycle()) {
+      throw new Error('Cannot compute topological order: Cycle detected in task graph');
+    }
+
+    const visited = new Set();
+    const order = [];
+
+    const visit = (taskId) => {
+      if (visited.has(taskId)) return;
+      visited.add(taskId);
+
+      const task = this.tasks.get(taskId);
+      if (task && Array.isArray(task.dependencies)) {
+        for (const depId of task.dependencies) {
+          if (this.tasks.has(depId)) {
+            visit(depId);
+          }
+        }
+      }
+      order.push(task);
+    };
+
+    for (const taskId of this.tasks.keys()) {
+      visit(taskId);
+    }
+
+    return order;
+  }
+
+  /**
+   * Returns all tasks ready to run (dependencies completed and task is queued/pending)
+   */
+  getReadyTasks() {
+    const ready = [];
+    for (const [id, task] of this.tasks.entries()) {
+      if (task.status === TASK_STATUS.QUEUED || task.status === TASK_STATUS.PENDING) {
+        const depsMet = task.dependencies.every(depId => this.completedTaskIds.has(depId));
+        if (depsMet) {
+          ready.push(task);
+        }
+      }
+    }
+    return ready;
+  }
+
+  markRunning(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.status = TASK_STATUS.RUNNING;
+    task.updatedAt = Date.now();
+    this.runningTaskIds.add(taskId);
+  }
+
+  markCompleted(taskId, result = null) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.status = TASK_STATUS.COMPLETED;
+    task.result = result;
+    task.updatedAt = Date.now();
+    this.runningTaskIds.delete(taskId);
+    this.completedTaskIds.add(taskId);
+  }
+
+  markFailed(taskId, error = null) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.status = TASK_STATUS.FAILED;
+    task.error = typeof error === 'string' ? error : (error?.message || 'Unknown error');
+    task.updatedAt = Date.now();
+    this.runningTaskIds.delete(taskId);
+    this.failedTaskIds.add(taskId);
+  }
+
+  isCompleted() {
+    return this.tasks.size > 0 && this.tasks.size === this.completedTaskIds.size;
+  }
+
+  hasFailed() {
+    return this.failedTaskIds.size > 0;
+  }
+
+  reset() {
+    this.completedTaskIds.clear();
+    this.runningTaskIds.clear();
+    this.failedTaskIds.clear();
+    for (const task of this.tasks.values()) {
+      task.status = TASK_STATUS.QUEUED;
+      task.result = null;
+      task.error = null;
+      task.updatedAt = Date.now();
+    }
+  }
+
+  toJSON() {
+    return Array.from(this.tasks.values());
+  }
+}