@pixelbyte-software/pixcode 1.55.0 → 1.55.1

package/server/modules/tasks/task-queue.ts

@@ -1,91 +0,0 @@
-// ============================================================
-// Task Queue — Manages task dependencies and concurrency
-// ============================================================
-
-import { getTask, updateTask, getTasksByStatus, getPredecessor } from './task-store.js';
-import { taskEvents } from './task-runner.js';
-import type { Task, TaskStatus } from './task-types.js';
-
-const TERMINAL_STATUSES: TaskStatus[] = ['COMPLETED', 'FAILED', 'CANCELLED'];
-
-// Default concurrency: 3 concurrent tasks
-let MAX_CONCURRENT = parseInt(process.env.PIXCODE_MAX_CONCURRENT_TASKS || '3', 10);
-
-export function setMaxConcurrent(n: number): void {
-  MAX_CONCURRENT = Math.max(1, n);
-}
-
-export function getMaxConcurrent(): number {
-  return MAX_CONCURRENT;
-}
-
-/**
- * Enqueue a task — checks predecessor, transitions to QUEUED if ready.
- */
-export async function enqueue(taskId: string): Promise<void> {
-  const task = getTask(taskId);
-  if (!task) throw new Error(`Task ${taskId} not found`);
-
-  // Check predecessor
-  if (task.predecessorTaskId) {
-    const predecessor = getPredecessor(task);
-    if (predecessor && !TERMINAL_STATUSES.includes(predecessor.status)) {
-      // Predecessor still running — task stays PENDING
-      return;
-    }
-    if (predecessor && predecessor.status !== 'COMPLETED') {
-      // Predecessor failed or cancelled — cancel this task too
-      updateTask(taskId, {
-        status: 'CANCELLED',
-        result: `Predecessor task "${predecessor.title}" is ${predecessor.status}`,
-      });
-      taskEvents.emit('task:status', { taskId, status: 'CANCELLED' });
-      return;
-    }
-    // Predecessor completed — continue session if requested
-    if (predecessor && task.continueSession && predecessor.sessionId) {
-      updateTask(taskId, { sessionId: predecessor.sessionId });
-    }
-  }
-
-  // Ready to queue
-  updateTask(taskId, { status: 'QUEUED' });
-  taskEvents.emit('task:status', { taskId, status: 'QUEUED' });
-}
-
-/**
- * Get tasks that are ready to run (QUEUED + within concurrency limit).
- */
-export function getTasksToRun(): Task[] {
-  const runningCount = getTasksByStatus('RUNNING').length +
-    getTasksByStatus('AWAITING_INPUT').length;
-
-  if (runningCount >= MAX_CONCURRENT) return [];
-
-  const queued = getTasksByStatus('QUEUED');
-  const slotsAvailable = MAX_CONCURRENT - runningCount;
-
-  // Sort by priority then creation time
-  const priorityOrder: Record<string, number> = { urgent: 0, high: 1, normal: 2, low: 3 };
-  return queued
-    .sort((a, b) => {
-      const pDiff = (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
-      if (pDiff !== 0) return pDiff;
-      return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
-    })
-    .slice(0, slotsAvailable);
-}
-
-/**
- * Called when a task terminates — check if dependent tasks can proceed.
- */
-export async function onTaskTerminated(taskId: string): Promise<void> {
-  // Find tasks that have this task as predecessor
-  // We need to scan all PENDING tasks
-  const pending = getTasksByStatus('PENDING');
-  for (const p of pending) {
-    if (p.predecessorTaskId === taskId) {
-      await enqueue(p.id);
-    }
-  }
-}

package/server/modules/tasks/task-routes.ts

@@ -1,245 +0,0 @@
-// ============================================================
-// Task Routes — Express API endpoints for task management
-// ============================================================
-
-import type { Router, Request, Response } from 'express';
-import express from 'express';
-
-import {
-  createTask,
-  getTask,
-  getTasksByProject,
-  getAllTasks,
-  updateTask,
-  deleteTask,
-  getLogs,
-  getPendingInteractions,
-  addLog,
-} from './task-store.js';
-import { enqueue } from './task-queue.js';
-import { cancelTask, taskEvents } from './task-runner.js';
-import { submitAnswer } from './user-interaction.js';
-import { getMaxConcurrent, setMaxConcurrent } from './task-queue.js';
-import { listRoles } from './role-presets.js';
-import type { CreateTaskInput, AgentType, TaskRole, TaskPriority } from './task-types.js';
-
-export function taskRouter(): Router {
-  const router = express.Router();
-
-  // ============================================================
-  // GET /api/tasks — List all tasks
-  // ============================================================
-  router.get('/', (req: Request, res: Response) => {
-    const limit = parseInt(String(req.query.limit)) || 100;
-    const projectId = String(req.query.projectId);
-    const tasks = projectId ? getTasksByProject(projectId) : getAllTasks(limit);
-    res.json({ tasks });
-  });
-
-  // ============================================================
-  // GET /api/tasks/:id — Get a single task
-  // ============================================================
-  router.get('/:id', (req: Request, res: Response) => {
-    const task = getTask(String(req.params.id));
-    if (!task) {
-      res.status(404).json({ error: 'Task not found' });
-      return;
-    }
-    res.json({ task });
-  });
-
-  // ============================================================
-  // POST /api/tasks — Create a new task
-  // ============================================================
-  router.post('/', async (req: Request, res: Response) => {
-    try {
-      const {
-        projectId,
-        title,
-        prompt,
-        agentType,
-        model,
-        role,
-        priority,
-        predecessorTaskId,
-        continueSession,
-        maxBudgetUsd,
-        interactionTimeout,
-        thinkingEnabled,
-        permissionMode,
-      } = req.body;
-
-      if (!projectId || !title || !prompt || !agentType) {
-        res.status(400).json({
-          error: 'Missing required fields: projectId, title, prompt, agentType',
-        });
-        return;
-      }
-
-      const validAgents: AgentType[] = ['claude-code', 'codex', 'gemini', 'qwen', 'opencode'];
-      if (!validAgents.includes(agentType)) {
-        res.status(400).json({ error: `Invalid agentType. Valid: ${validAgents.join(', ')}` });
-        return;
-      }
-
-      const input: CreateTaskInput = {
-        projectId,
-        title,
-        prompt,
-        agentType,
-        model,
-        role: role as TaskRole,
-        priority: priority as TaskPriority,
-        predecessorTaskId,
-        continueSession,
-        maxBudgetUsd,
-        interactionTimeout,
-        thinkingEnabled,
-        permissionMode,
-      };
-
-      const task = createTask(input);
-      await enqueue(task.id);
-      taskEvents.emit('task:enqueued', task.id);
-
-      res.status(201).json({ task });
-    } catch (err: any) {
-      res.status(500).json({ error: err.message });
-    }
-  });
-
-  // ============================================================
-  // POST /api/tasks/:id/cancel — Cancel a task
-  // ============================================================
-  router.post('/:id/cancel', async (req: Request, res: Response) => {
-    const success = await cancelTask(String(req.params.id));
-    if (!success) {
-      res.status(404).json({ error: 'Task not found' });
-      return;
-    }
-    res.json({ success: true });
-  });
-
-  // ============================================================
-  // DELETE /api/tasks/:id — Delete a task
-  // ============================================================
-  router.delete('/:id', (req: Request, res: Response) => {
-    const success = deleteTask(String(req.params.id));
-    if (!success) {
-      res.status(404).json({ error: 'Task not found' });
-      return;
-    }
-    res.json({ success: true });
-  });
-
-  // ============================================================
-  // GET /api/tasks/:id/logs — Get task logs
-  // ============================================================
-  router.get('/:id/logs', (req: Request, res: Response) => {
-    const limit = parseInt(String(req.query.limit)) || 200;
-    const logs = getLogs(String(req.params.id), limit);
-    res.json({ logs });
-  });
-
-  // ============================================================
-  // GET /api/tasks/:id/interactions — Get pending interactions
-  // ============================================================
-  router.get('/:id/interactions', (req: Request, res: Response) => {
-    const interactions = getPendingInteractions(String(req.params.id));
-    res.json({ interactions });
-  });
-
-  // ============================================================
-  // POST /api/tasks/interactions/:interactionId/answer — Answer a question
-  // ============================================================
-  router.post('/interactions/:interactionId/answer', (req: Request, res: Response) => {
-    const { answer } = req.body;
-    if (!answer) {
-      res.status(400).json({ error: 'Missing required field: answer' });
-      return;
-    }
-    const success = submitAnswer(String(req.params.interactionId), answer);
-    if (!success) {
-      res.status(404).json({ error: 'Interaction not found or already answered' });
-      return;
-    }
-    res.json({ success: true });
-  });
-
-  // ============================================================
-  // GET /api/tasks/meta/roles — List available roles
-  // ============================================================
-  router.get('/meta/roles', (req: Request, res: Response) => {
-    res.json({ roles: listRoles() });
-  });
-
-  // ============================================================
-  // GET /api/tasks/meta/agents — List available agents
-  // ============================================================
-  router.get('/meta/agents', (req: Request, res: Response) => {
-    res.json({
-      agents: [
-        { value: 'claude-code', label: 'Claude Code', provider: 'anthropic' },
-        { value: 'codex', label: 'Codex CLI', provider: 'openai' },
-        { value: 'gemini', label: 'Gemini CLI', provider: 'google' },
-        { value: 'qwen', label: 'Qwen Code', provider: 'alibaba' },
-        { value: 'opencode', label: 'OpenCode', provider: 'anomaly' },
-      ],
-    });
-  });
-
-  // ============================================================
-  // GET /api/tasks/meta/config — Get task system config
-  // ============================================================
-  router.get('/meta/config', (req: Request, res: Response) => {
-    res.json({
-      maxConcurrent: getMaxConcurrent(),
-    });
-  });
-
-  // ============================================================
-  // POST /api/tasks/meta/config — Set task system config
-  // ============================================================
-  router.post('/meta/config', (req: Request, res: Response) => {
-    const { maxConcurrent } = req.body;
-    if (typeof maxConcurrent === 'number' && maxConcurrent > 0) {
-      setMaxConcurrent(maxConcurrent);
-    }
-    res.json({ maxConcurrent: getMaxConcurrent() });
-  });
-
-  // ============================================================
-  // WebSocket event stream (SSE) — /api/tasks/events
-  // ============================================================
-  router.get('/events', (req: Request, res: Response) => {
-    res.writeHead(200, {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
-    });
-
-    const send = (data: any) => {
-      res.write(`data: ${JSON.stringify(data)}\n\n`);
-    };
-
-    const handlers: Record<string, (data: any) => void> = {
-      'task:status': (data) => send({ type: 'task:status', ...data }),
-      'task:log': (data) => send({ type: 'task:log', ...data }),
-      'task:completed': (data) => send({ type: 'task:completed', ...data }),
-      'task:failed': (data) => send({ type: 'task:failed', ...data }),
-      'task:cancelled': (data) => send({ type: 'task:cancelled', ...data }),
-    };
-
-    for (const [event, handler] of Object.entries(handlers)) {
-      taskEvents.on(event, handler);
-    }
-
-    req.on('close', () => {
-      for (const [event, handler] of Object.entries(handlers)) {
-        taskEvents.off(event, handler);
-      }
-    });
-  });
-
-  return router;
-}

package/server/modules/tasks/task-runner.ts

@@ -1,219 +0,0 @@
-// ============================================================
-// Task Runner — Dispatches tasks to the right agent runner
-// ============================================================
-
-import { updateTask, addLog, getTask } from './task-store.js';
-import { createWorktree, removeWorktree, getChangedFiles } from './git-worktree.js';
-import { askUser, cancelTaskInteractions } from './user-interaction.js';
-import { buildSummaryPrompt } from './prompt-builder.js';
-import { claudeRunner } from './runners/claude-runner.js';
-import { codexRunner } from './runners/codex-runner.js';
-import { createSpawnRunner } from './runners/spawn-runner.js';
-import type { Task, AgentType } from './task-types.js';
-import type { AgentRunner, RunContext } from './runners/types.js';
-
-// Runner registry
-const runners: Partial<Record<AgentType, AgentRunner>> = {
-  'claude-code': claudeRunner,
-  'codex': codexRunner,
-  'gemini': createSpawnRunner('gemini'),
-  'qwen': createSpawnRunner('qwen'),
-  'opencode': createSpawnRunner('opencode'),
-};
-
-// Track running tasks for cancellation
-const runningTasks = new Map<string, AbortController>();
-
-export function getAbortController(taskId: string): AbortController | undefined {
-  return runningTasks.get(taskId);
-}
-
-// Event emitter for WebSocket updates
-import { EventEmitter } from 'node:events';
-export const taskEvents = new EventEmitter();
-
-// ============================================================
-// Resolve project path from projectId
-// ============================================================
-
-export async function resolveProjectPath(projectId: string): Promise<string> {
-  // Try to import pixcode's project service
-  try {
-    const { getProjects } = await import('../../projects.js');
-    const projects = await getProjects();
-    const project = projects.find((p: any) => p.name === projectId || p.id === projectId);
-    if (project) {
-      return project.fullPath || project.path || projectId;
-    }
-  } catch {
-    // Fall through to treating projectId as a path
-  }
-  return projectId;
-}
-
-// ============================================================
-// Generate summary using Claude SDK
-// ============================================================
-
-async function generateSummary(task: Task, projectPath: string): Promise<string> {
-  try {
-    const { query } = await import('@anthropic-ai/claude-agent-sdk');
-    const summaryPrompt = buildSummaryPrompt(task);
-
-    const response = await query({
-      prompt: summaryPrompt,
-      options: {
-        cwd: task.worktreePath || projectPath,
-        maxTurns: 3,
-        model: 'claude-sonnet-4-20250514',
-        permissionMode: 'plan' as any,
-      },
-    });
-
-    let summary = '';
-    for await (const message of response) {
-      if (message.type === 'result' && message.subtype === 'success') {
-        const success = message as any;
-        summary = success.result || '';
-      }
-    }
-    return summary.slice(0, 2000);
-  } catch {
-    // Fallback: simple summary
-    return `Task "${task.title}" completed with ${task.agentType}.`;
-  }
-}
-
-// ============================================================
-// Run a single task
-// ============================================================
-
-export async function runTask(task: Task, projectPath: string): Promise<void> {
-  const abortController = new AbortController();
-  runningTasks.set(task.id, abortController);
-
-  const logTask = (level: 'info' | 'warn' | 'error' | 'debug', message: string) => {
-    addLog(task.id, level, message);
-    taskEvents.emit('task:log', { taskId: task.id, level, message });
-  };
-
-  const broadcastStatus = (status: string) => {
-    taskEvents.emit('task:status', { taskId: task.id, status });
-  };
-
-  try {
-    // Update status to RUNNING
-    updateTask(task.id, {
-      status: 'RUNNING',
-      startedAt: new Date().toISOString(),
-    });
-    broadcastStatus('RUNNING');
-
-    // Create git worktree for isolation
-    let worktreePath: string | undefined;
-    let branchName: string | undefined;
-    try {
-      const wt = createWorktree(task, projectPath);
-      worktreePath = wt.worktreePath;
-      branchName = wt.branchName;
-      updateTask(task.id, { worktreePath, branchName });
-    } catch (err: any) {
-      logTask('warn', `Could not create worktree: ${err.message}. Running in main directory.`);
-    }
-
-    // Get the right runner
-    const runner = runners[task.agentType];
-    if (!runner) {
-      throw new Error(`No runner registered for agent type: ${task.agentType}`);
-    }
-
-    // Build context
-    const ctx: RunContext = {
-      task: { ...task, worktreePath, branchName },
-      projectPath,
-      abortController,
-      logTask,
-      broadcastStatus,
-      askUser: (question: string, options?: string[]) =>
-        askUser(task.id, question, options, task.interactionTimeout),
-    };
-
-    // Run the agent
-    const { result, costUsd, tokenCount, sessionId } = await runner.run(ctx);
-
-    // Get changed files
-    const changedFiles = getChangedFiles({ ...task, worktreePath }, projectPath);
-
-    // Generate summary
-    logTask('info', 'Generating task summary...');
-    const summary = await generateSummary({ ...task, worktreePath }, projectPath);
-
-    // Update task with results
-    updateTask(task.id, {
-      status: 'COMPLETED',
-      result: result || 'Completed',
-      summary,
-      costUsd: costUsd || 0,
-      tokenCount: tokenCount || { input: 0, output: 0 },
-      sessionId,
-      changedFiles,
-      completedAt: new Date().toISOString(),
-    });
-    broadcastStatus('COMPLETED');
-
-    logTask('info', `Task completed. Cost: $${(costUsd || 0).toFixed(4)}, Files changed: ${changedFiles.length}`);
-
-    taskEvents.emit('task:completed', {
-      taskId: task.id,
-      summary,
-      costUsd: costUsd || 0,
-      changedFiles,
-    });
-
-    // Clean up worktree (optional — keep for review)
-    // removeWorktree(updatedTask, projectPath);
-
-  } catch (err: any) {
-    logTask('error', `Task failed: ${err.message}`);
-
-    updateTask(task.id, {
-      status: 'FAILED',
-      result: err.message,
-      completedAt: new Date().toISOString(),
-    });
-    broadcastStatus('FAILED');
-
-    taskEvents.emit('task:failed', { taskId: task.id, error: err.message });
-  } finally {
-    runningTasks.delete(task.id);
-  }
-}
-
-// ============================================================
-// Cancel a running task
-// ============================================================
-
-export async function cancelTask(taskId: string): Promise<boolean> {
-  const task = getTask(taskId);
-  if (!task) return false;
-
-  // Abort the running process
-  const abortController = runningTasks.get(taskId);
-  if (abortController) {
-    abortController.abort();
-  }
-
-  // Cancel pending interactions
-  cancelTaskInteractions(taskId);
-
-  // Update status
-  updateTask(taskId, {
-    status: 'CANCELLED',
-    completedAt: new Date().toISOString(),
-  });
-
-  taskEvents.emit('task:status', { taskId, status: 'CANCELLED' });
-  taskEvents.emit('task:cancelled', { taskId });
-
-  return true;
-}