@pixelbyte-software/pixcode 1.55.0 → 1.55.1

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

@@ -1,223 +0,0 @@
-// ============================================================
-// Task Store — JSON-backed persistent storage for tasks
-// ============================================================
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import { randomUUID } from 'node:crypto';
-
-import { findAppRoot, getModuleDir } from '@/utils/runtime-paths.js';
-
-import type { Task, TaskInteraction, TaskLog, TaskStatus, CreateTaskInput } from './task-types.js';
-
-const require = createRequire(import.meta.url);
-const __dirname = getModuleDir(import.meta.url);
-const APP_ROOT = findAppRoot(__dirname);
-
-const TASKS_FILE = process.env.PIXCODE_TASKS_DB || path.join(APP_ROOT, 'tasks.json');
-
-interface TaskStoreData {
-  _version: number;
-  tasks: Task[];
-  interactions: TaskInteraction[];
-  logs: TaskLog[];
-}
-
-function loadStore(): TaskStoreData {
-  try {
-    if (fs.existsSync(TASKS_FILE)) {
-      const raw = fs.readFileSync(TASKS_FILE, 'utf-8');
-      const data = JSON.parse(raw);
-      if (!data.tasks) data.tasks = [];
-      if (!data.interactions) data.interactions = [];
-      if (!data.logs) data.logs = [];
-      return data;
-    }
-  } catch (err) {
-    console.error('[task-store] Failed to load tasks.json:', err);
-  }
-  return { _version: 1, tasks: [], interactions: [], logs: [] };
-}
-
-function saveStore(data: TaskStoreData): void {
-  try {
-    const dir = path.dirname(TASKS_FILE);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    const tmp = TASKS_FILE + '.tmp';
-    fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
-    fs.renameSync(tmp, TASKS_FILE);
-  } catch (err) {
-    console.error('[task-store] Failed to save tasks.json:', err);
-  }
-}
-
-// In-memory cache — loaded once, kept in sync
-let storeData = loadStore();
-
-// Rate-limit saves to avoid hammering disk on every log write
-let saveTimer: NodeJS.Timeout | null = null;
-function scheduleSave(): void {
-  if (saveTimer) return;
-  saveTimer = setTimeout(() => {
-    saveTimer = null;
-    saveStore(storeData);
-  }, 500);
-}
-
-// Force immediate save (for critical state changes)
-function flushSave(): void {
-  if (saveTimer) {
-    clearTimeout(saveTimer);
-    saveTimer = null;
-  }
-  saveStore(storeData);
-}
-
-// ============================================================
-// Task CRUD
-// ============================================================
-
-export function createTask(input: CreateTaskInput): Task {
-  const now = new Date().toISOString();
-  const task: Task = {
-    id: randomUUID(),
-    projectId: input.projectId,
-    title: input.title,
-    prompt: input.prompt,
-    status: 'PENDING',
-    agentType: input.agentType,
-    model: input.model,
-    role: input.role || 'fullstack',
-    priority: input.priority || 'normal',
-    predecessorTaskId: input.predecessorTaskId,
-    continueSession: input.continueSession || false,
-    maxBudgetUsd: input.maxBudgetUsd,
-    interactionTimeout: input.interactionTimeout || 300_000,
-    thinkingEnabled: input.thinkingEnabled || false,
-    permissionMode: input.permissionMode,
-    costUsd: 0,
-    tokenCount: { input: 0, output: 0 },
-    createdAt: now,
-  };
-  storeData.tasks.push(task);
-  flushSave();
-  return task;
-}
-
-export function getTask(id: string): Task | undefined {
-  return storeData.tasks.find((t) => t.id === id);
-}
-
-export function getTasksByProject(projectId: string): Task[] {
-  return storeData.tasks
-    .filter((t) => t.projectId === projectId)
-    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-}
-
-export function getAllTasks(limit = 100): Task[] {
-  return storeData.tasks
-    .slice()
-    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
-    .slice(0, limit);
-}
-
-export function updateTask(id: string, updates: Partial<Task>): Task | undefined {
-  const task = storeData.tasks.find((t) => t.id === id);
-  if (!task) return undefined;
-  Object.assign(task, updates, { updatedAt: new Date().toISOString() });
-  flushSave();
-  return task;
-}
-
-export function deleteTask(id: string): boolean {
-  const idx = storeData.tasks.findIndex((t) => t.id === id);
-  if (idx === -1) return false;
-  storeData.tasks.splice(idx, 1);
-  // Also remove related interactions and logs
-  storeData.interactions = storeData.interactions.filter((i) => i.taskId !== id);
-  storeData.logs = storeData.logs.filter((l) => l.taskId !== id);
-  flushSave();
-  return true;
-}
-
-export function getTasksByStatus(status: TaskStatus): Task[] {
-  return storeData.tasks.filter((t) => t.status === status);
-}
-
-export function getPredecessor(task: Task): Task | undefined {
-  if (!task.predecessorTaskId) return undefined;
-  return getTask(task.predecessorTaskId);
-}
-
-// ============================================================
-// Task Interactions
-// ============================================================
-
-export function createInteraction(taskId: string, question: string, options?: string[]): TaskInteraction {
-  const interaction: TaskInteraction = {
-    id: randomUUID(),
-    taskId,
-    question,
-    options,
-    status: 'pending',
-    createdAt: new Date().toISOString(),
-  };
-  storeData.interactions.push(interaction);
-  flushSave();
-  return interaction;
-}
-
-export function getPendingInteractions(taskId: string): TaskInteraction[] {
-  return storeData.interactions.filter(
-    (i) => i.taskId === taskId && i.status === 'pending',
-  );
-}
-
-export function answerInteraction(interactionId: string, answer: string): TaskInteraction | undefined {
-  const interaction = storeData.interactions.find((i) => i.id === interactionId);
-  if (!interaction) return undefined;
-  interaction.answer = answer;
-  interaction.status = 'answered';
-  interaction.answeredAt = new Date().toISOString();
-  flushSave();
-  return interaction;
-}
-
-export function timeoutInteraction(interactionId: string): void {
-  const interaction = storeData.interactions.find((i) => i.id === interactionId);
-  if (interaction && interaction.status === 'pending') {
-    interaction.status = 'timeout';
-    flushSave();
-  }
-}
-
-// ============================================================
-// Task Logs
-// ============================================================
-
-export function addLog(taskId: string, level: TaskLog['level'], message: string): void {
-  storeData.logs.push({
-    id: randomUUID(),
-    taskId,
-    level,
-    message,
-    timestamp: new Date().toISOString(),
-  });
-  scheduleSave();
-}
-
-export function getLogs(taskId: string, limit = 200): TaskLog[] {
-  return storeData.logs
-    .filter((l) => l.taskId === taskId)
-    .sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime())
-    .slice(-limit);
-}
-
-// ============================================================
-// Utility
-// ============================================================
-
-export function getTaskStorePath(): string {
-  return TASKS_FILE;
-}

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

@@ -1,100 +0,0 @@
-// ============================================================
-// Task Types — Core type definitions for the task system
-// ============================================================
-
-export type TaskStatus =
-  | 'PENDING'       // Created but waiting for predecessor or queue slot
-  | 'QUEUED'        // Ready to run, waiting for scheduler
-  | 'RUNNING'       // Agent is executing
-  | 'AWAITING_INPUT' // Agent asked a question, waiting for user
-  | 'COMPLETED'     // Finished successfully
-  | 'FAILED'        // Finished with error
-  | 'CANCELLED';    // User cancelled
-
-export type AgentType = 'claude-code' | 'codex' | 'gemini' | 'qwen' | 'opencode';
-
-export type TaskRole = 'backend' | 'frontend' | 'fullstack' | 'reviewer' | 'tester' | 'custom';
-
-export type TaskPriority = 'low' | 'normal' | 'high' | 'urgent';
-
-export interface TaskInteraction {
-  id: string;
-  taskId: string;
-  question: string;
-  options?: string[];
-  answer?: string;
-  status: 'pending' | 'answered' | 'timeout';
-  createdAt: string;
-  answeredAt?: string;
-}
-
-export interface TaskLog {
-  id: string;
-  taskId: string;
-  level: 'info' | 'warn' | 'error' | 'debug';
-  message: string;
-  timestamp: string;
-}
-
-export interface Task {
-  id: string;
-  projectId: string;
-  title: string;
-  prompt: string;
-  status: TaskStatus;
-  agentType: AgentType;
-  model?: string;
-  role: TaskRole;
-  priority: TaskPriority;
-
-  // Dependency chain — predecessor must complete before this starts
-  predecessorTaskId?: string;
-  continueSession?: boolean;  // Continue predecessor's session
-  sessionId?: string;         // Session ID from agent (for continuation)
-
-  // Budget
-  maxBudgetUsd?: number;
-  costUsd?: number;
-  tokenCount?: { input: number; output: number };
-
-  // Git worktree
-  branchName?: string;
-  worktreePath?: string;
-
-  // Result
-  result?: string;
-  summary?: string;
-  changedFiles?: string[];
-
-  // Timestamps
-  createdAt: string;
-  startedAt?: string;
-  completedAt?: string;
-
-  // Metadata
-  interactionTimeout?: number;  // ms, default 300000 (5 min)
-  thinkingEnabled?: boolean;
-  permissionMode?: string;
-}
-
-export interface CreateTaskInput {
-  projectId: string;
-  title: string;
-  prompt: string;
-  agentType: AgentType;
-  model?: string;
-  role?: TaskRole;
-  priority?: TaskPriority;
-  predecessorTaskId?: string;
-  continueSession?: boolean;
-  maxBudgetUsd?: number;
-  interactionTimeout?: number;
-  thinkingEnabled?: boolean;
-  permissionMode?: string;
-}
-
-export interface DispatchTaskInput {
-  agentType: AgentType;
-  model?: string;
-  permissionMode?: string;
-}

package/server/modules/tasks/user-interaction.ts

@@ -1,93 +0,0 @@
-// ============================================================
-// User Interaction — Agent asks questions, user responds via UI
-// ============================================================
-
-import { EventEmitter } from 'node:events';
-
-import { createInteraction, answerInteraction, getPendingInteractions, timeoutInteraction, addLog } from './task-store.js';
-
-// Event bus for WebSocket notifications
-export const interactionEvents = new EventEmitter();
-
-// Pending interaction promises — keyed by interaction ID
-const pendingResolvers = new Map<string, { resolve: (answer: string) => void; reject: (err: Error) => void; timer: NodeJS.Timeout }>();
-
-/**
- * Create a question for the user and wait for the answer.
- * Called by agent runners when the agent needs user input.
- */
-export function askUser(
-  taskId: string,
-  question: string,
-  options?: string[],
-  timeoutMs = 300_000,
-): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const interaction = createInteraction(taskId, question, options);
-
-    // Emit event for WebSocket broadcast
-    interactionEvents.emit('interaction:created', {
-      taskId,
-      interactionId: interaction.id,
-      question,
-      options,
-    });
-
-    addLog(taskId, 'info', `Agent asked: "${question.slice(0, 100)}"`);
-
-    // Set timeout
-    const timer = setTimeout(() => {
-      timeoutInteraction(interaction.id);
-      pendingResolvers.delete(interaction.id);
-      addLog(taskId, 'warn', `Interaction timed out: "${question.slice(0, 60)}"`);
-      resolve('[TIMEOUT] No response from user');
-    }, timeoutMs);
-
-    pendingResolvers.set(interaction.id, { resolve, reject, timer });
-  });
-}
-
-/**
- * Called when user answers a question via the UI.
- */
-export function submitAnswer(interactionId: string, answer: string): boolean {
-  const pending = pendingResolvers.get(interactionId);
-  if (!pending) return false;
-
-  clearTimeout(pending.timer);
-  pendingResolvers.delete(interactionId);
-
-  // Persist the answer
-  answerInteraction(interactionId, answer);
-
-  // Resolve the promise
-  pending.resolve(answer);
-
-  // Emit event for WebSocket broadcast
-  interactionEvents.emit('interaction:answered', { interactionId, answer });
-
-  return true;
-}
-
-/**
- * Get all pending interactions for a task.
- */
-export function getTaskInteractions(taskId: string) {
-  return getPendingInteractions(taskId);
-}
-
-/**
- * Cancel all pending interactions for a task (e.g. when task is cancelled).
- */
-export function cancelTaskInteractions(taskId: string): void {
-  const pending = getPendingInteractions(taskId);
-  for (const interaction of pending) {
-    const resolver = pendingResolvers.get(interaction.id);
-    if (resolver) {
-      clearTimeout(resolver.timer);
-      pendingResolvers.delete(interaction.id);
-      resolver.resolve('[CANCELLED] Task was cancelled');
-    }
-    timeoutInteraction(interaction.id);
-  }
-}