@pixelbyte-software/pixcode 1.54.10 → 1.55.0

package/server/modules/tasks/git-worktree.ts

@@ -0,0 +1,102 @@
+// ============================================================
+// Git Worktree — Isolated working directory per task
+// ============================================================
+
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { addLog } from './task-store.js';
+import { buildBranchName } from './prompt-builder.js';
+import type { Task } from './task-types.js';
+
+function git(projectPath: string, ...args: string[]): string {
+  const result = execSync(`git ${args.map((a) => `"${a.replace(/"/g, '\\"')}"`).join(' ')}`, {
+    cwd: projectPath,
+    encoding: 'utf-8',
+    timeout: 30_000,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  return result.trim();
+}
+
+export function createWorktree(task: Task, projectPath: string): { branchName: string; worktreePath: string } {
+  const branchName = buildBranchName(task);
+
+  // Make sure the main repo is clean enough to create a worktree
+  try {
+    git(projectPath, 'rev-parse', 'HEAD');
+  } catch {
+    throw new Error(`Project path is not a git repository: ${projectPath}`);
+  }
+
+  // Create a new branch from current HEAD and a worktree for it
+  const worktreeBase = path.join(projectPath, '..', '.pixcode-worktrees');
+  if (!fs.existsSync(worktreeBase)) {
+    fs.mkdirSync(worktreeBase, { recursive: true });
+  }
+
+  const worktreePath = path.join(worktreeBase, task.id.slice(0, 8));
+
+  try {
+    // Create branch + worktree in one command
+    git(projectPath, 'worktree', 'add', '-b', branchName, worktreePath, 'HEAD');
+    addLog(task.id, 'info', `Created worktree at ${worktreePath} on branch ${branchName}`);
+  } catch (err: any) {
+    // If branch already exists, try without -b
+    try {
+      git(projectPath, 'worktree', 'add', worktreePath, branchName);
+      addLog(task.id, 'info', `Reused existing branch ${branchName} in worktree at ${worktreePath}`);
+    } catch (err2: any) {
+      throw new Error(`Failed to create worktree: ${err.message || err2.message}`);
+    }
+  }
+
+  return { branchName, worktreePath };
+}
+
+export function removeWorktree(task: Task, projectPath: string): void {
+  if (!task.worktreePath || !fs.existsSync(task.worktreePath)) return;
+
+  try {
+    git(projectPath, 'worktree', 'remove', task.worktreePath, '--force');
+    addLog(task.id, 'info', `Removed worktree at ${task.worktreePath}`);
+  } catch (err: any) {
+    // Fallback: manual removal
+    try {
+      fs.rmSync(task.worktreePath, { recursive: true, force: true });
+      git(projectPath, 'worktree', 'prune');
+      addLog(task.id, 'info', `Force-removed worktree at ${task.worktreePath}`);
+    } catch {
+      addLog(task.id, 'warn', `Could not remove worktree: ${err.message}`);
+    }
+  }
+
+  // Optionally delete the branch
+  if (task.branchName) {
+    try {
+      git(projectPath, 'branch', '-D', task.branchName);
+    } catch {
+      // Branch might be checked out or have unmerged commits — not critical
+    }
+  }
+}
+
+export function getChangedFiles(task: Task, projectPath: string): string[] {
+  const wtPath = task.worktreePath || projectPath;
+  try {
+    const diff = git(wtPath, 'diff', '--name-only', 'HEAD~1');
+    return diff.split('\n').filter(Boolean);
+  } catch {
+    try {
+      // Maybe no commits yet — check unstaged
+      const status = git(wtPath, 'status', '--porcelain');
+      return status
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => line.slice(3).trim());
+    } catch {
+      return [];
+    }
+  }
+}

package/server/modules/tasks/index.ts

@@ -0,0 +1,9 @@
+// ============================================================
+// Task System — Public API
+// ============================================================
+
+export { taskRouter } from './task-routes.js';
+export { taskScheduler } from './scheduler.js';
+export { enqueue, getTasksToRun, getMaxConcurrent, setMaxConcurrent } from './task-queue.js';
+export { runTask, cancelTask, taskEvents } from './task-runner.js';
+export type { Task, TaskStatus, AgentType, TaskRole, CreateTaskInput } from './task-types.js';

package/server/modules/tasks/prompt-builder.ts

@@ -0,0 +1,98 @@
+// ============================================================
+// Prompt Builder — Constructs prompts for agents
+// ============================================================
+
+import type { Task } from './task-types.js';
+import { getRolePromptAppend } from './role-presets.js';
+
+export function buildPrompt(task: Task, projectPath: string): string {
+  const roleAppend = getRolePromptAppend(task.role);
+  const parts: string[] = [];
+
+  parts.push(`## Task: ${task.title}`);
+  parts.push('');
+  parts.push(task.prompt);
+  parts.push('');
+
+  if (roleAppend) {
+    parts.push('---');
+    parts.push('');
+    parts.push(roleAppend);
+    parts.push('');
+  }
+
+  parts.push('---');
+  parts.push('');
+  parts.push(`## Context`);
+  parts.push(`- Working directory: ${projectPath}`);
+  parts.push(`- Agent: ${task.agentType}`);
+  if (task.model) {
+    parts.push(`- Model: ${task.model}`);
+  }
+  if (task.maxBudgetUsd) {
+    parts.push(`- Budget limit: $${task.maxBudgetUsd}`);
+  }
+  parts.push('');
+  parts.push('## Instructions');
+  parts.push('1. Analyze the codebase before making changes');
+  parts.push('2. Make focused, minimal changes');
+  parts.push('3. Run existing tests if available');
+  parts.push('4. Provide a summary of what you changed and why');
+  if (task.permissionMode !== 'plan') {
+    parts.push('5. Commit your changes with a descriptive message');
+  }
+  parts.push('');
+
+  return parts.join('\n');
+}
+
+export function buildContinuePrompt(task: Task): string {
+  const roleAppend = getRolePromptAppend(task.role);
+  const parts: string[] = [];
+
+  parts.push(`## Continuing Task: ${task.title}`);
+  parts.push('');
+  parts.push('You are continuing from a previous session. Review the work done so far and proceed.');
+  parts.push('');
+  parts.push('### Original request:');
+  parts.push(task.prompt);
+  parts.push('');
+
+  if (roleAppend) {
+    parts.push('---');
+    parts.push('');
+    parts.push(roleAppend);
+    parts.push('');
+  }
+
+  parts.push('## Instructions');
+  parts.push('1. Check git log and recent changes to see what was already done');
+  parts.push('2. Continue from where the previous session left off');
+  parts.push('3. Do NOT redo work that is already complete');
+  parts.push('4. Run tests to verify existing work');
+  parts.push('5. Complete the remaining work and commit');
+  parts.push('');
+
+  return parts.join('\n');
+}
+
+export function buildBranchName(task: Task): string {
+  const slug = task.title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+  return `task/${task.id.slice(0, 8)}-${slug}`;
+}
+
+export function buildSummaryPrompt(task: Task): string {
+  return `Summarize the work completed for this task in 3-5 bullet points:
+- Task: ${task.title}
+- Agent: ${task.agentType}
+- What was the original request: ${task.prompt.slice(0, 200)}
+- What files were changed (check git diff)
+- Were tests run? Did they pass?
+- Any issues or follow-up needed?
+
+Provide only the summary, no preamble.`;
+}

package/server/modules/tasks/role-presets.ts

@@ -0,0 +1,113 @@
+// ============================================================
+// Role Presets — Default system prompts per role type
+// Inspired by VibeHQ's team model
+// ============================================================
+
+import type { TaskRole, AgentType } from './task-types.js';
+
+export interface RolePreset {
+  role: TaskRole;
+  label: string;
+  description: string;
+  defaultAgent: AgentType;
+  systemPromptAppend: string;
+}
+
+export const ROLE_PRESETS: Record<TaskRole, RolePreset> = {
+  backend: {
+    role: 'backend',
+    label: 'Backend Engineer',
+    description: 'API routes, database, server logic, authentication',
+    defaultAgent: 'claude-code',
+    systemPromptAppend: `You are a backend engineer. Focus on:
+- API design and implementation (REST/GraphQL)
+- Database schema, migrations, queries
+- Server-side logic, middleware, authentication
+- Error handling, validation, security
+- Performance optimization (caching, indexing)
+Write clean, well-tested backend code. Add inline comments for complex logic.`,
+  },
+
+  frontend: {
+    role: 'frontend',
+    label: 'Frontend Engineer',
+    description: 'UI components, styles, user experience, client logic',
+    defaultAgent: 'codex',
+    systemPromptAppend: `You are a frontend engineer. Focus on:
+- React/Vue/Svelte components and pages
+- CSS/Tailwind/styled-components styling
+- Client-side state management
+- Form handling, validation, UX flows
+- Accessibility (ARIA, semantic HTML)
+- Responsive design
+Write clean, accessible, well-styled frontend code. Test in the browser when possible.`,
+  },
+
+  fullstack: {
+    role: 'fullstack',
+    label: 'Full-Stack Engineer',
+    description: 'End-to-end features across frontend and backend',
+    defaultAgent: 'claude-code',
+    systemPromptAppend: `You are a full-stack engineer. Handle both frontend and backend.
+- Design and implement end-to-end features
+- Keep API contracts consistent between frontend and backend
+- Write tests for both layers
+- Consider deployment and infrastructure implications`,
+  },
+
+  reviewer: {
+    role: 'reviewer',
+    label: 'Code Reviewer',
+    description: 'Review changes for bugs, security, performance, style',
+    defaultAgent: 'gemini',
+    systemPromptAppend: `You are a code reviewer. Analyze the changes for:
+- Logic errors and edge cases
+- Security vulnerabilities (OWASP top 10)
+- Performance issues
+- Code style and maintainability
+- Missing tests or documentation
+Provide a prioritized list of findings. Be specific about file:line.`,
+  },
+
+  tester: {
+    role: 'tester',
+    label: 'Test Engineer',
+    description: 'Write and run tests, ensure coverage',
+    defaultAgent: 'codex',
+    systemPromptAppend: `You are a test engineer. Focus on:
+- Unit tests for individual functions/modules
+- Integration tests for API endpoints
+- Edge cases and error scenarios
+- Test coverage gaps
+Use the project's existing test framework. Run tests after writing them.`,
+  },
+
+  custom: {
+    role: 'custom',
+    label: 'Custom',
+    description: 'No role-specific prompt — use the raw prompt',
+    defaultAgent: 'claude-code',
+    systemPromptAppend: '',
+  },
+};
+
+export function getRolePreset(role: TaskRole): RolePreset {
+  return ROLE_PRESETS[role] || ROLE_PRESETS.custom;
+}
+
+export function getRolePromptAppend(role: TaskRole): string {
+  return getRolePreset(role).systemPromptAppend;
+}
+
+export function getDefaultAgentForRole(role: TaskRole): AgentType {
+  return getRolePreset(role).defaultAgent;
+}
+
+export function listRoles(): { value: TaskRole; label: string; description: string; defaultAgent: AgentType }[] {
+  return Object.values(ROLE_PRESETS).map((p) => ({
+    value: p.role,
+    label: p.label,
+    description: p.description,
+    defaultAgent: p.defaultAgent,
+  }));
+}

package/server/modules/tasks/runners/claude-runner.ts

@@ -0,0 +1,120 @@
+// ============================================================
+// Claude Runner — Uses @anthropic-ai/claude-agent-sdk
+// ============================================================
+
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
+import { buildPrompt, buildContinuePrompt } from '../prompt-builder.js';
+import type { AgentRunner, RunContext, RunResult } from './types.js';
+
+export const claudeRunner: AgentRunner = {
+  async run(ctx: RunContext): Promise<RunResult> {
+    const { task, projectPath, abortController } = ctx;
+    const workdir = task.worktreePath || projectPath;
+
+    // Build prompt — continue or fresh
+    const prompt = task.continueSession && task.predecessorTaskId
+      ? buildContinuePrompt(task)
+      : buildPrompt(task, workdir);
+
+    // Build clean env
+    const cleanEnv: Record<string, string | undefined> = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+
+    // Permission mode
+    const permissionMode = task.permissionMode || 'auto_edit';
+
+    await ctx.logTask('info', `Starting Claude Code agent. Model: ${task.model || 'default'}, Permission: ${permissionMode}`);
+
+    let resultText = '';
+    let costUsd = 0;
+    let tokenInput = 0;
+    let tokenOutput = 0;
+    let sessionId: string | undefined;
+
+    try {
+      const response = query({
+        prompt,
+        options: {
+          cwd: workdir,
+          model: task.model,
+          permissionMode: permissionMode as any,
+          maxTurns: 150,
+          env: cleanEnv,
+          abortController,
+          ...(task.continueSession && task.sessionId
+            ? { resume: task.sessionId }
+            : {}),
+        },
+      });
+
+      for await (const message of response) {
+        if (abortController.signal.aborted) break;
+
+        switch (message.type) {
+          case 'assistant': {
+            if (message.message?.content) {
+              for (const block of message.message.content) {
+                if (block.type === 'text') {
+                  resultText += block.text + '\n';
+                  await ctx.logTask('info', `[Claude] ${block.text.slice(0, 200)}`);
+                }
+              }
+            }
+            // Extract token usage
+            if (message.message?.usage) {
+              tokenInput += message.message.usage.input_tokens || 0;
+              tokenOutput += message.message.usage.output_tokens || 0;
+              costUsd += ((message.message.usage.input_tokens || 0) * 0.000003) +
+                         ((message.message.usage.output_tokens || 0) * 0.000015);
+            }
+            break;
+          }
+
+          case 'result': {
+            // SDKResultMessage is a union — check subtype before accessing fields
+            if (message.subtype === 'success') {
+              const success = message as any;
+              if (success.result) resultText = success.result;
+              if (success.session_id) sessionId = success.session_id;
+              if (success.total_cost_usd) costUsd = success.total_cost_usd;
+              if (success.usage) {
+                tokenInput = success.usage.input_tokens || tokenInput;
+                tokenOutput = success.usage.output_tokens || tokenOutput;
+              }
+            }
+            break;
+          }
+
+          case 'system': {
+            if (message.subtype === 'init' && message.session_id) {
+              sessionId = message.session_id;
+              await ctx.logTask('info', `Claude session: ${sessionId}`);
+            }
+            break;
+          }
+        }
+      }
+
+      // Check budget
+      if (task.maxBudgetUsd && costUsd > task.maxBudgetUsd) {
+        await ctx.logTask('warn', `Budget exceeded: $${costUsd.toFixed(4)} > $${task.maxBudgetUsd}`);
+      }
+
+      await ctx.logTask('info', `Claude completed. Tokens: ${tokenInput} in / ${tokenOutput} out. Cost: $${costUsd.toFixed(4)}`);
+
+      return {
+        result: resultText.slice(0, 10000),
+        costUsd,
+        tokenCount: { input: tokenInput, output: tokenOutput },
+        sessionId,
+      };
+    } catch (err: any) {
+      if (err?.name === 'AbortError' || abortController.signal.aborted) {
+        await ctx.logTask('info', 'Claude task was cancelled');
+        return { result: 'Task cancelled by user', sessionId };
+      }
+      throw err;
+    }
+  },
+};

package/server/modules/tasks/runners/codex-runner.ts

@@ -0,0 +1,80 @@
+// ============================================================
+// Codex Runner — Uses @openai/codex-sdk
+// ============================================================
+
+import { Codex } from '@openai/codex-sdk';
+
+import { buildPrompt, buildContinuePrompt } from '../prompt-builder.js';
+import type { AgentRunner, RunContext, RunResult } from './types.js';
+
+export const codexRunner: AgentRunner = {
+  async run(ctx: RunContext): Promise<RunResult> {
+    const { task, projectPath, abortController } = ctx;
+    const workdir = task.worktreePath || projectPath;
+
+    const prompt = task.continueSession && task.predecessorTaskId
+      ? buildContinuePrompt(task)
+      : buildPrompt(task, workdir);
+
+    // Clean env
+    const cleanEnv: Record<string, string> = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (v !== undefined && k !== 'CLAUDECODE') {
+        cleanEnv[k] = v;
+      }
+    }
+
+    await ctx.logTask('info', `Starting Codex agent. Model: ${task.model || 'o4-mini'}, Thinking: ${task.thinkingEnabled}`);
+
+    const codex = new Codex({
+      env: cleanEnv,
+      config: {
+        model: task.model || 'o4-mini',
+        approval_policy: 'never',
+        ...(task.thinkingEnabled ? { reasoning_effort: 'high' as const } : {}),
+      },
+    });
+
+    let resultText = '';
+    let costUsd = 0;
+    let tokenInput = 0;
+    let tokenOutput = 0;
+    let sessionId: string | undefined;
+
+    try {
+      // Use startThread() — the correct Codex SDK API
+      const thread = codex.startThread();
+
+      // Use run() for non-streaming — returns a Turn with finalResponse and usage
+      const turn = await thread.run(prompt, {
+        signal: abortController.signal,
+      });
+
+      // Extract results from the completed turn
+      resultText = turn.finalResponse || '';
+      sessionId = thread.id || undefined;
+
+      if (turn.usage) {
+        tokenInput = turn.usage.input_tokens || 0;
+        tokenOutput = turn.usage.output_tokens || 0;
+        costUsd = (tokenInput * 0.0000025) + (tokenOutput * 0.00001);
+      }
+
+      await ctx.logTask('info', `[Codex] ${resultText.slice(0, 200)}`);
+      await ctx.logTask('info', `Codex completed. Tokens: ${tokenInput} in / ${tokenOutput} out. Cost: $${costUsd.toFixed(4)}`);
+
+      return {
+        result: resultText.slice(0, 10000),
+        costUsd,
+        tokenCount: { input: tokenInput, output: tokenOutput },
+        sessionId,
+      };
+    } catch (err: any) {
+      if (err?.name === 'AbortError' || abortController.signal.aborted) {
+        await ctx.logTask('info', 'Codex task was cancelled');
+        return { result: 'Task cancelled by user', sessionId };
+      }
+      throw err;
+    }
+  },
+};

package/server/modules/tasks/runners/spawn-runner.ts

@@ -0,0 +1,122 @@
+// ============================================================
+// Spawn Runner — Generic CLI spawn runner for Gemini, Qwen, OpenCode
+// Uses child_process spawn with real-time output streaming
+// ============================================================
+
+import { spawn } from 'node:child_process';
+
+import { buildPrompt, buildContinuePrompt } from '../prompt-builder.js';
+import type { AgentRunner, RunContext, RunResult } from './types.js';
+
+// CLI command mapping
+const CLI_COMMANDS: Record<string, { bin: string; args: string[]; promptFlag: string }> = {
+  gemini: {
+    bin: 'gemini',
+    args: ['--yolo'],
+    promptFlag: '-p',
+  },
+  qwen: {
+    bin: 'qwen',
+    args: [],
+    promptFlag: '-p',
+  },
+  opencode: {
+    bin: 'opencode',
+    args: ['run'],
+    promptFlag: '',
+  },
+};
+
+function getCliCommand(agentType: string, model?: string): { bin: string; args: string[]; promptFlag: string } {
+  const config = CLI_COMMANDS[agentType];
+  if (!config) throw new Error(`Unknown CLI agent: ${agentType}`);
+  const args = [...config.args];
+  if (model && agentType === 'gemini') args.push('--model', model);
+  if (model && agentType === 'qwen') args.push('--model', model);
+  return { ...config, args };
+}
+
+export function createSpawnRunner(agentType: string): AgentRunner {
+  return {
+    async run(ctx: RunContext): Promise<RunResult> {
+      const { task, projectPath, abortController } = ctx;
+      const workdir = task.worktreePath || projectPath;
+
+      const prompt = task.continueSession && task.predecessorTaskId
+        ? buildContinuePrompt(task)
+        : buildPrompt(task, workdir);
+
+      const { bin, args, promptFlag } = getCliCommand(agentType, task.model);
+
+      const fullArgs = promptFlag
+        ? [...args, promptFlag, prompt]
+        : [...args, prompt];
+
+      await ctx.logTask('info', `Starting ${agentType} agent. Bin: ${bin}, Model: ${task.model || 'default'}`);
+
+      return new Promise<RunResult>((resolve, reject) => {
+        const child = spawn(bin, fullArgs, {
+          cwd: workdir,
+          env: { ...process.env },
+          stdio: ['pipe', 'pipe', 'pipe'],
+          shell: false,
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout?.on('data', (data: Buffer) => {
+          const text = data.toString('utf-8');
+          stdout += text;
+          // Log chunks
+          const lines = text.split('\n').filter(Boolean);
+          for (const line of lines) {
+            ctx.logTask('info', `[${agentType}] ${line.slice(0, 200)}`);
+          }
+        });
+
+        child.stderr?.on('data', (data: Buffer) => {
+          const text = data.toString('utf-8');
+          stderr += text;
+          const lines = text.split('\n').filter(Boolean);
+          for (const line of lines) {
+            ctx.logTask('warn', `[${agentType}] ${line.slice(0, 200)}`);
+          }
+        });
+
+        // Handle abort
+        const abortHandler = () => {
+          try {
+            child.kill('SIGTERM');
+            setTimeout(() => {
+              if (!child.killed) child.kill('SIGKILL');
+            }, 5000);
+          } catch {}
+        };
+        abortController.signal.addEventListener('abort', abortHandler, { once: true });
+
+        child.on('close', (code: number) => {
+          abortController.signal.removeEventListener('abort', abortHandler);
+
+          if (code === 0 || abortController.signal.aborted) {
+            ctx.logTask('info', `${agentType} completed. Exit code: ${code}`);
+            resolve({
+              result: stdout.slice(0, 10000),
+              costUsd: 0, // CLI doesn't report cost directly
+              tokenCount: { input: 0, output: 0 },
+            });
+          } else {
+            ctx.logTask('error', `${agentType} failed. Exit code: ${code}. stderr: ${stderr.slice(0, 500)}`);
+            reject(new Error(`${agentType} exited with code ${code}: ${stderr.slice(0, 500)}`));
+          }
+        });
+
+        child.on('error', (err: Error) => {
+          abortController.signal.removeEventListener('abort', abortHandler);
+          ctx.logTask('error', `${agentType} spawn error: ${err.message}`);
+          reject(err);
+        });
+      });
+    },
+  };
+}

package/server/modules/tasks/runners/types.ts

@@ -0,0 +1,25 @@
+// ============================================================
+// Runner Types — Interface for agent runners
+// ============================================================
+
+import type { Task } from '../task-types.js';
+
+export interface RunContext {
+  task: Task;
+  projectPath: string;
+  abortController: AbortController;
+  logTask: (level: 'info' | 'warn' | 'error' | 'debug', message: string) => void;
+  broadcastStatus: (status: string) => void;
+  askUser: (question: string, options?: string[]) => Promise<string>;
+}
+
+export interface RunResult {
+  result?: string;
+  costUsd?: number;
+  tokenCount?: { input: number; output: number };
+  sessionId?: string;
+}
+
+export interface AgentRunner {
+  run(ctx: RunContext): Promise<RunResult>;
+}