@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/runtime/tasks/adapters/agent-adapter.ts

@@ -1,208 +0,0 @@
-/**
- * AgentTaskAdapter — bridges agent sessions (AgentOrchestrator / WRFC agents)
- * into the unified RuntimeTask registry.
- *
- * Each running agent gets a corresponding RuntimeTask of kind 'agent'. The
- * adapter maps agent lifecycle state strings to task lifecycle transitions.
- */
-
-import { randomUUID } from 'node:crypto';
-import { createDomainDispatch } from '../../store/index.ts';
-import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
-import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
-import type { AgentLifecycleState } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/agents';
-
-/** Owner context for an agent task. */
-export interface AgentOwner {
-  /** Session ID that spawned this agent. */
-  sessionId: string;
-}
-
-/** Terminal agent lifecycle states that map to terminal task states. */
-const TERMINAL_STATES: ReadonlySet<AgentLifecycleState> = new Set([
-  'completed',
-  'failed',
-  'cancelled',
-]);
-
-/** Active (non-terminal, non-queued) agent states that map to 'running'. */
-const RUNNING_STATES: ReadonlySet<AgentLifecycleState> = new Set([
-  'running',
-  'awaiting_message',
-  'awaiting_tool',
-  'finalizing',
-]);
-
-/**
- * Maps an agent lifecycle state string to a RuntimeTask lifecycle state.
- *
- * @param state - Agent lifecycle state from AgentLifecycleState.
- * @returns Corresponding task lifecycle state.
- */
-function mapAgentStateToTask(
-  state: AgentLifecycleState,
-): 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' {
-  if (state === 'spawning') return 'queued';
-  if (RUNNING_STATES.has(state)) return 'running';
-  if (state === 'completed') return 'completed';
-  if (state === 'failed') return 'failed';
-  if (state === 'cancelled') return 'cancelled';
-  return 'running'; // fallback for unknown states
-}
-
-/**
- * Bridges agent sessions into the RuntimeTask registry.
- *
- * @example
- * ```ts
- * const adapter = new AgentTaskAdapter(store);
- * const taskId = adapter.wrapAgent('agent_1', 'Fix the linting errors', { sessionId: 'sess_1' });
- * adapter.handleAgentStateChange('agent_1', 'running');
- * adapter.handleAgentStateChange('agent_1', 'completed');
- * ```
- */
-export class AgentTaskAdapter {
-  /** Maps agent ID → task ID. */
-  private readonly _agentToTask = new Map<string, string>();
-  /** Maps task ID → agent ID. */
-  private readonly _taskToAgent = new Map<string, string>();
-
-  private readonly _dispatch: DomainDispatch;
-
-  constructor(private readonly _store: RuntimeStore) {
-    this._dispatch = createDomainDispatch(_store);
-  }
-
-  // ── Core API ────────────────────────────────────────────────────────────────
-
-  /**
-   * Wrap an agent session as a RuntimeTask.
-   *
-   * @param agentId - Unique agent ID from the agent system.
-   * @param task - Human-readable description of what the agent is doing.
-   * @param owner - Session that spawned this agent.
-   * @returns The new task ID.
-   */
-  wrapAgent(agentId: string, task: string, owner: AgentOwner): string {
-    // Idempotent: return existing task ID if already wrapped
-    const existing = this._agentToTask.get(agentId);
-    if (existing !== undefined) return existing;
-
-    const taskId = randomUUID();
-    const now = Date.now();
-
-    const runtimeTask: RuntimeTask = {
-      id: taskId,
-      kind: 'agent',
-      title: task.length > 80 ? `${task.slice(0, 77)}...` : task,
-      description: task,
-      status: 'queued',
-      owner: agentId,
-      cancellable: true,
-      childTaskIds: [],
-      queuedAt: now,
-      correlationId: owner.sessionId,
-    };
-
-    this._agentToTask.set(agentId, taskId);
-    this._taskToAgent.set(taskId, agentId);
-
-    this._upsertTask(runtimeTask);
-    return taskId;
-  }
-
-  /**
-   * Handle an agent lifecycle state change and transition the task accordingly.
-   *
-   * @param agentId - The agent whose state changed.
-   * @param state - New agent lifecycle state (AgentLifecycleState string).
-   */
-  handleAgentStateChange(agentId: string, state: AgentLifecycleState): void {
-    const taskId = this._agentToTask.get(agentId);
-    if (taskId === undefined) return;
-
-    const agentState = state;
-    const taskStatus = mapAgentStateToTask(agentState);
-
-    this._transitionTask(taskId, taskStatus, {
-      isTerminal: TERMINAL_STATES.has(agentState),
-      error: agentState === 'failed' ? `Agent ${agentId} failed` : undefined,
-    });
-
-    // Clean up mappings once terminal
-    if (TERMINAL_STATES.has(agentState)) {
-      this._agentToTask.delete(agentId);
-      this._taskToAgent.delete(taskId);
-    }
-  }
-
-  /**
-   * Cancel an agent task by task ID.
-   * Marks the task as cancelled in the store. The caller is responsible for
-   * actually stopping the agent session.
-   *
-   * @param taskId - The RuntimeTask ID to cancel.
-   */
-  cancelAgent(taskId: string): void {
-    const agentId = this._taskToAgent.get(taskId);
-    if (agentId === undefined) return;
-
-    this._transitionTask(taskId, 'cancelled', { isTerminal: true });
-    this._agentToTask.delete(agentId);
-    this._taskToAgent.delete(taskId);
-  }
-
-  /**
-   * Reconcile adapter state with an external agent registry snapshot.
-   *
-   * @param activeAgents - Current snapshot of active agents: agentId → task description.
-   * @param owner - Default owner context for auto-wrapped agents.
-   */
-  sync(activeAgents: ReadonlyMap<string, string>, owner: AgentOwner = { sessionId: 'system' }): void {
-    const liveIds = new Set(activeAgents.keys());
-
-    // Wrap newly discovered agents
-    for (const [agentId, task] of activeAgents.entries()) {
-      if (!this._agentToTask.has(agentId)) {
-        this.wrapAgent(agentId, task, owner);
-      }
-    }
-
-    // Mark stale tracked agents as cancelled
-    const staleAgentIds: string[] = [];
-    for (const [agentId] of this._agentToTask.entries()) {
-      if (!liveIds.has(agentId)) staleAgentIds.push(agentId);
-    }
-    for (const agentId of staleAgentIds) {
-      const taskId = this._agentToTask.get(agentId)!;
-      this._transitionTask(taskId, 'cancelled', { isTerminal: true });
-      this._agentToTask.delete(agentId);
-      this._taskToAgent.delete(taskId);
-    }
-  }
-
-  // ── Private helpers ─────────────────────────────────────────────────────────
-
-  private _upsertTask(task: RuntimeTask): void {
-    this._dispatch.syncRuntimeTask(task, 'agent-adapter');
-  }
-
-  private _transitionTask(
-    taskId: string,
-    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled',
-    opts: { isTerminal?: boolean; error?: string },
-  ): void {
-    const current = this._store.getState().tasks.tasks.get(taskId);
-    const timestamp = Date.now();
-    this._dispatch.transitionRuntimeTask(
-      taskId,
-      status,
-      {
-        startedAt: status === 'running' && current?.startedAt === undefined ? timestamp : current?.startedAt,
-        endedAt: opts.isTerminal ? timestamp : current?.endedAt,
-        error: opts.error,
-      },
-      'agent-adapter',
-    );
-  }
-}

package/src/runtime/tasks/adapters/index.ts

@@ -1,16 +0,0 @@
-/**
- * Task adapter barrel — re-exports all subsystem-to-RuntimeTask bridge adapters.
- *
- * Each adapter converts a subsystem-specific task representation into the
- * unified RuntimeTask model and handles lifecycle transitions.
- */
-
-export { ProcessTaskAdapter } from '@pellux/goodvibes-sdk/platform/runtime/tasks/adapters/process-adapter';
-export type { ProcessOwner } from '@pellux/goodvibes-sdk/platform/runtime/tasks/adapters/process-adapter';
-
-export { AgentTaskAdapter } from '@pellux/goodvibes-sdk/platform/runtime/tasks/adapters/agent-adapter';
-export type { AgentOwner } from '@pellux/goodvibes-sdk/platform/runtime/tasks/adapters/agent-adapter';
-
-export { AcpTaskAdapter } from '@pellux/goodvibes-sdk/platform/runtime/tasks/adapters/acp-adapter';
-
-export { SchedulerTaskAdapter } from '@pellux/goodvibes-sdk/platform/runtime/tasks/adapters/scheduler-adapter';

package/src/runtime/tasks/adapters/process-adapter.ts

@@ -1,214 +0,0 @@
-/**
- * ProcessTaskAdapter — bridges ProcessManager background processes into the
- * unified RuntimeTask registry.
- *
- * Each spawned background process gets a corresponding RuntimeTask of kind
- * 'exec'. The adapter tracks the pid→taskId mapping and reconciles state
- * on demand via sync().
- *
- * NOTE: This adapter writes directly to the Zustand store for performance,
- * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
- * This is intentional — adapters are authoritative sources for their subsystem.
- */
-
-import { randomUUID } from 'node:crypto';
-import { createDomainDispatch } from '../../store/index.ts';
-import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
-import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
-import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools/shared/process-manager';
-
-/** Owner context supplied when wrapping a process. */
-export interface ProcessOwner {
-  /** Session ID that spawned this process. */
-  sessionId: string;
-  /** Optional agent ID that owns this process. */
-  agentId?: string;
-}
-
-/**
- * Bridges ProcessManager background processes into the RuntimeTask registry.
- *
- * @example
- * ```ts
- * const adapter = new ProcessTaskAdapter(store);
- * const taskId = adapter.wrapProcess(proc.pid, 'npm run build', { sessionId: 'sess_1' });
- * // later...
- * adapter.handleProcessExit(proc.pid, 0);
- * ```
- */
-export class ProcessTaskAdapter {
-  /** Maps process internal ID (bg_N_ts) → task ID. */
-  private readonly _idToTask = new Map<string, string>();
-  /** Maps task ID → process internal ID. */
-  private readonly _taskToId = new Map<string, string>();
-  /** Maps pid → process internal ID (for exit handling). */
-  private readonly _pidToId = new Map<number, string>();
-
-  private readonly _manager: ProcessManager;
-  private readonly _dispatch: DomainDispatch;
-
-  constructor(
-    private readonly _store: RuntimeStore,
-    manager: ProcessManager,
-  ) {
-    this._manager = manager;
-    this._dispatch = createDomainDispatch(_store);
-  }
-
-  // ── Core API ────────────────────────────────────────────────────────────────
-
-  /**
-   * Wrap a spawned process as a RuntimeTask.
-   *
-   * @param processId - The ProcessManager internal ID (process_id from spawn result).
-   * @param pid - OS process ID.
-   * @param command - The shell command string for display.
-   * @param owner - Session/agent that owns this process.
-   * @returns The new task ID.
-   */
-  wrapProcess(
-    processId: string,
-    pid: number,
-    command: string,
-    owner: ProcessOwner,
-  ): string {
-    // Idempotent: if already wrapped, return existing task ID
-    const existing = this._idToTask.get(processId);
-    if (existing !== undefined) return existing;
-
-    const taskId = randomUUID();
-    const now = Date.now();
-
-    const task: RuntimeTask = {
-      id: taskId,
-      kind: 'exec',
-      title: command.length > 80 ? `${command.slice(0, 77)}...` : command,
-      description: command,
-      status: 'running',
-      owner: owner.agentId ?? owner.sessionId,
-      cancellable: true,
-      childTaskIds: [],
-      queuedAt: now,
-      startedAt: now,
-      correlationId: owner.sessionId,
-      turnId: owner.agentId,
-    };
-
-    this._idToTask.set(processId, taskId);
-    this._taskToId.set(taskId, processId);
-    this._pidToId.set(pid, processId);
-
-    this._upsertTask(task);
-    return taskId;
-  }
-
-  /**
-   * Update task status when a process exits.
-   *
-   * @param pid - OS process ID that exited.
-   * @param exitCode - Process exit code (0 = success).
-   */
-  handleProcessExit(pid: number, exitCode: number): void {
-    const processId = this._pidToId.get(pid);
-    if (processId === undefined) return;
-
-    const taskId = this._idToTask.get(processId);
-    if (taskId === undefined) return;
-
-    this._pidToId.delete(pid);
-
-    this._transitionTask(taskId, exitCode === 0 ? 'completed' : 'failed', {
-      exitCode,
-      error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
-    });
-  }
-
-  /**
-   * Cancel a process task by task ID.
-   * Stops the underlying process via ProcessManager and marks the task cancelled.
-   *
-   * @param taskId - The RuntimeTask ID to cancel.
-   */
-  cancelProcess(taskId: string): void {
-    const processId = this._taskToId.get(taskId);
-    if (processId === undefined) return;
-
-    // Look up the pid before stopping so we can clean up _pidToId
-    const entry = this._manager.getStatus(processId);
-    this._manager.stop(processId);
-    if (entry !== undefined) {
-      this._pidToId.delete(entry.pid);
-    }
-    this._transitionTask(taskId, 'cancelled', {});
-  }
-
-  /**
-   * Reconcile adapter state with the RuntimeTask registry.
-   *
-   * Scans all ProcessManager processes:
-   * - Wraps any un-tracked processes as new tasks (with a fallback owner).
-   * - Marks completed (done) processes as completed or failed in the task store.
-   * - Removes task mappings for processes that have been cleaned up.
-   *
-   * @param defaultOwner - Owner context used when auto-wrapping unknown processes.
-   */
-  sync(defaultOwner: ProcessOwner = { sessionId: 'system' }): void {
-    const liveProcesses = this._manager.list();
-    const liveIds = new Set(liveProcesses.map((p) => p.id));
-
-    // Handle processes not yet tracked
-    for (const proc of liveProcesses) {
-      if (!this._idToTask.has(proc.id)) {
-        // Use the real pid from list() for accurate _pidToId tracking
-        this.wrapProcess(proc.id, proc.pid, proc.cmd, defaultOwner);
-      }
-
-      // Check if the process has finished
-      const entry = this._manager.getStatus(proc.id);
-      if (entry?.done) {
-        const taskId = this._idToTask.get(proc.id);
-        if (taskId !== undefined) {
-          const exitCode = entry.exitCode ?? 1;
-          this._transitionTask(taskId, exitCode === 0 ? 'completed' : 'failed', {
-            exitCode,
-            error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
-          });
-        }
-      }
-    }
-
-    // Clean up stale mappings for processes no longer tracked by the manager
-    const staleProcessIds: string[] = [];
-    for (const [processId] of this._idToTask.entries()) {
-      if (!liveIds.has(processId)) staleProcessIds.push(processId);
-    }
-    for (const processId of staleProcessIds) {
-      const taskId = this._idToTask.get(processId)!;
-      this._idToTask.delete(processId);
-      this._taskToId.delete(taskId);
-    }
-  }
-
-  // ── Private helpers ─────────────────────────────────────────────────────────
-
-  private _upsertTask(task: RuntimeTask): void {
-    this._dispatch.syncRuntimeTask(task, 'process-adapter');
-  }
-
-  private _transitionTask(
-    taskId: string,
-    status: 'completed' | 'failed' | 'cancelled',
-    extras: { exitCode?: number; error?: string },
-  ): void {
-    this._dispatch.transitionRuntimeTask(
-      taskId,
-      status,
-      {
-        endedAt: Date.now(),
-        exitCode: extras.exitCode,
-        error: extras.error,
-      },
-      'process-adapter',
-    );
-  }
-}

package/src/runtime/tasks/adapters/scheduler-adapter.ts

@@ -1,193 +0,0 @@
-/**
- * SchedulerTaskAdapter — bridges TaskScheduler scheduled job executions into
- * the unified RuntimeTask registry.
- *
- * Each time a scheduled task fires (i.e. TaskRunRecord is created), a
- * corresponding RuntimeTask of kind 'scheduler' is registered. The adapter
- * tracks runRecord agentId → task ID and handles completion via state sync.
- *
- * NOTE: This adapter writes directly to the Zustand store for performance,
- * bypassing TaskManager. Lifecycle validation is the caller's responsibility.
- * This is intentional — adapters are authoritative sources for their subsystem.
- */
-
-import { randomUUID } from 'node:crypto';
-import { createDomainDispatch } from '../../store/index.ts';
-import type { RuntimeStore, DomainDispatch } from '../../store/index.ts';
-import type { RuntimeTask } from '@pellux/goodvibes-sdk/platform/runtime/store/domains/tasks';
-import type { TaskScheduler, ScheduledTask, TaskRunRecord } from '@pellux/goodvibes-sdk/platform/scheduler/scheduler';
-
-/**
- * Bridges TaskScheduler job executions into the RuntimeTask registry.
- *
- * The scheduler runs jobs that spawn agent sessions. Each run is tracked as a
- * RuntimeTask of kind 'scheduler'. The run's agentId is used as the correlation
- * key between the scheduler's TaskRunRecord and the RuntimeTask.
- *
- * @example
- * ```ts
- * const adapter = new SchedulerTaskAdapter(store);
- * // When a scheduled task fires:
- * const taskId = adapter.wrapScheduledRun(record, scheduledTask);
- * // When the run completes:
- * adapter.handleRunComplete(record.agentId, 'completed');
- * ```
- */
-export class SchedulerTaskAdapter {
-  /** Maps run agentId → task ID. */
-  private readonly _runToTask = new Map<string, string>();
-  /** Maps task ID → run agentId. */
-  private readonly _taskToRun = new Map<string, string>();
-
-  private readonly _dispatch: DomainDispatch;
-
-  constructor(private readonly _store: RuntimeStore) {
-    this._dispatch = createDomainDispatch(_store);
-  }
-
-  // ── Core API ────────────────────────────────────────────────────────────────
-
-  /**
-   * Wrap a scheduled task run as a RuntimeTask.
-   *
-   * @param record - The TaskRunRecord from the scheduler.
-   * @param scheduledTask - The parent ScheduledTask definition.
-   * @returns The new task ID.
-   */
-  wrapScheduledRun(record: TaskRunRecord, scheduledTask: ScheduledTask): string {
-    // Idempotent: return existing if already wrapped
-    const existing = this._runToTask.get(record.agentId);
-    if (existing !== undefined) return existing;
-
-    const taskId = randomUUID();
-    const now = record.startedAt;
-
-    const task: RuntimeTask = {
-      id: taskId,
-      kind: 'scheduler',
-      title: `Scheduled: ${scheduledTask.name}`,
-      description: scheduledTask.prompt.length > 200
-        ? `${scheduledTask.prompt.slice(0, 197)}...`
-        : scheduledTask.prompt,
-      status: record.status === 'running' ? 'running' : 'completed',
-      owner: `scheduler:${scheduledTask.id}`,
-      cancellable: record.status === 'running',
-      childTaskIds: [],
-      queuedAt: now,
-      startedAt: now,
-      endedAt: record.status !== 'running' ? Date.now() : undefined,
-      correlationId: record.agentId,
-      turnId: record.taskId,
-      error: record.error,
-    };
-
-    this._runToTask.set(record.agentId, taskId);
-    this._taskToRun.set(taskId, record.agentId);
-
-    this._upsertTask(task);
-    return taskId;
-  }
-
-  /**
-   * Handle a scheduled run completion or failure.
-   *
-   * @param runAgentId - The agentId from the TaskRunRecord.
-   * @param status - Terminal status: 'completed' or 'failed'.
-   * @param error - Optional error message if status is 'failed'.
-   */
-  handleRunComplete(
-    runAgentId: string,
-    status: 'completed' | 'failed',
-    error?: string,
-  ): void {
-    const taskId = this._runToTask.get(runAgentId);
-    if (taskId === undefined) return;
-
-    this._transitionTask(taskId, status, { error });
-    this._runToTask.delete(runAgentId);
-    this._taskToRun.delete(taskId);
-  }
-
-  /**
-   * Cancel a scheduled run task by task ID.
-   * Marks the task as cancelled. The caller is responsible for disabling the
-   * scheduled task via TaskScheduler.setEnabled().
-   *
-   * @param taskId - The RuntimeTask ID to cancel.
-   */
-  cancelScheduled(taskId: string): void {
-    const runAgentId = this._taskToRun.get(taskId);
-    if (runAgentId === undefined) return;
-
-    this._transitionTask(taskId, 'cancelled', {});
-    this._runToTask.delete(runAgentId);
-    this._taskToRun.delete(taskId);
-  }
-
-  /**
-   * Reconcile adapter state with the current TaskScheduler snapshot.
-   *
-   * Scans all run history records from the scheduler:
-   * - Wraps any un-tracked running jobs as new tasks.
-   * - Marks completed/failed jobs that are still showing as running.
-   *
-   * @param scheduler - The TaskScheduler instance to sync from.
-   */
-  sync(scheduler: TaskScheduler): void {
-    const scheduledTasks = scheduler.list();
-    const scheduledTaskMap = new Map<string, ScheduledTask>(
-      scheduledTasks.map((t) => [t.id, t]),
-    );
-
-    const allHistory = scheduler.getAllHistory();
-    const runningRuns = allHistory.filter((r) => r.status === 'running');
-
-    for (const record of runningRuns) {
-      const scheduledTask = scheduledTaskMap.get(record.taskId);
-      if (!scheduledTask) continue;
-
-      if (!this._runToTask.has(record.agentId)) {
-        this.wrapScheduledRun(record, scheduledTask);
-      }
-    }
-
-    // Reconcile tracked runs that are no longer running.
-    // Build a Map for O(1) history lookups — acceptable O(n) build at current scheduler scale.
-    const historyByAgentId = new Map<string, TaskRunRecord>(allHistory.map((r) => [r.agentId, r]));
-    const runningAgentIds = new Set(runningRuns.map((r) => r.agentId));
-    const staleRunIds: string[] = [];
-    for (const [runAgentId] of this._runToTask.entries()) {
-      if (!runningAgentIds.has(runAgentId)) staleRunIds.push(runAgentId);
-    }
-    for (const runAgentId of staleRunIds) {
-      const taskId = this._runToTask.get(runAgentId)!;
-      const record = historyByAgentId.get(runAgentId);
-      const terminalStatus = record?.status === 'failed' ? 'failed' : 'completed';
-      this._transitionTask(taskId, terminalStatus, { error: record?.error });
-      this._runToTask.delete(runAgentId);
-      this._taskToRun.delete(taskId);
-    }
-  }
-
-  // ── Private helpers ─────────────────────────────────────────────────────────
-
-  private _upsertTask(task: RuntimeTask): void {
-    this._dispatch.syncRuntimeTask(task, 'scheduler-adapter');
-  }
-
-  private _transitionTask(
-    taskId: string,
-    status: 'completed' | 'failed' | 'cancelled',
-    opts: { error?: string },
-  ): void {
-    this._dispatch.transitionRuntimeTask(
-      taskId,
-      status,
-      {
-        endedAt: Date.now(),
-        error: opts.error,
-      },
-      'scheduler-adapter',
-    );
-  }
-}