opencode-orchestrator 0.5.4 → 0.5.6

package/dist/core/async-agent.d.ts

@@ -1,100 +0,0 @@
-/**
- * Parallel Agent Manager - Session-based async agent execution
- *
- * Key safety features:
- * - Concurrency control per agent type (queue-based)
- * - Batched notifications (notify when ALL complete)
- * - Automatic memory cleanup (5 min after completion)
- * - TTL enforcement (30 min timeout)
- * - Output validation before completion
- * - Process-safe polling (unref)
- */
-import type { PluginInput } from "@opencode-ai/plugin";
-type OpencodeClient = PluginInput["client"];
-export interface ParallelTask {
-    id: string;
-    sessionID: string;
-    parentSessionID: string;
-    description: string;
-    agent: string;
-    status: "pending" | "running" | "completed" | "error" | "timeout";
-    startedAt: Date;
-    completedAt?: Date;
-    error?: string;
-    result?: string;
-    concurrencyKey?: string;
-}
-interface LaunchInput {
-    description: string;
-    prompt: string;
-    agent: string;
-    parentSessionID: string;
-}
-export declare class ParallelAgentManager {
-    private static _instance;
-    private tasks;
-    private pendingByParent;
-    private notifications;
-    private client;
-    private directory;
-    private concurrency;
-    private pollingInterval?;
-    private constructor();
-    static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
-    /**
-     * Launch an agent in a new session (async, non-blocking)
-     */
-    launch(input: LaunchInput): Promise<ParallelTask>;
-    /**
-     * Get task by ID
-     */
-    getTask(id: string): ParallelTask | undefined;
-    /**
-     * Get all running tasks
-     */
-    getRunningTasks(): ParallelTask[];
-    /**
-     * Get all tasks
-     */
-    getAllTasks(): ParallelTask[];
-    /**
-     * Get tasks by parent session
-     */
-    getTasksByParent(parentSessionID: string): ParallelTask[];
-    /**
-     * Cancel a running task
-     */
-    cancelTask(taskId: string): Promise<boolean>;
-    /**
-     * Get result from completed task
-     */
-    getResult(taskId: string): Promise<string | null>;
-    /**
-     * Set concurrency limit for agent type
-     */
-    setConcurrencyLimit(agentType: string, limit: number): void;
-    /**
-     * Get pending notification count
-     */
-    getPendingCount(parentSessionID: string): number;
-    /**
-     * Cleanup all state
-     */
-    cleanup(): void;
-    private trackPending;
-    private untrackPending;
-    private handleTaskError;
-    private startPolling;
-    private stopPolling;
-    private pollRunningTasks;
-    private validateSessionHasOutput;
-    private pruneExpiredTasks;
-    private scheduleCleanup;
-    private queueNotification;
-    private notifyParentIfAllComplete;
-    formatDuration(start: Date, end?: Date): string;
-}
-export declare const parallelAgentManager: {
-    getInstance: typeof ParallelAgentManager.getInstance;
-};
-export {};

package/dist/core/background.d.ts

@@ -1,78 +0,0 @@
-/**
- * Background Task Manager for OpenCode Orchestrator
- *
- * Enables running commands in the background and checking their status later.
- * This allows the AI to continue working while long-running tasks execute.
- */
-import { ChildProcess } from "child_process";
-export type TaskStatus = "pending" | "running" | "done" | "error" | "timeout";
-export interface BackgroundTask {
-    id: string;
-    command: string;
-    args: string[];
-    cwd: string;
-    label?: string;
-    status: TaskStatus;
-    output: string;
-    errorOutput: string;
-    exitCode: number | null;
-    startTime: number;
-    endTime?: number;
-    timeout: number;
-    process?: ChildProcess;
-}
-export interface RunBackgroundOptions {
-    command: string;
-    cwd?: string;
-    timeout?: number;
-    label?: string;
-}
-declare class BackgroundTaskManager {
-    private static _instance;
-    private tasks;
-    private debugMode;
-    private constructor();
-    static get instance(): BackgroundTaskManager;
-    /**
-     * Generate a unique task ID in the format job_xxxxxxxx
-     */
-    private generateId;
-    /**
-     * Debug logging helper
-     */
-    private debug;
-    /**
-     * Run a command in the background
-     */
-    run(options: RunBackgroundOptions): BackgroundTask;
-    /**
-     * Get task by ID
-     */
-    get(taskId: string): BackgroundTask | undefined;
-    /**
-     * Get all tasks
-     */
-    getAll(): BackgroundTask[];
-    /**
-     * Get tasks by status
-     */
-    getByStatus(status: TaskStatus): BackgroundTask[];
-    /**
-     * Clear completed/failed tasks
-     */
-    clearCompleted(): number;
-    /**
-     * Kill a running task
-     */
-    kill(taskId: string): boolean;
-    /**
-     * Format duration for display
-     */
-    formatDuration(task: BackgroundTask): string;
-    /**
-     * Get status emoji
-     */
-    getStatusEmoji(status: TaskStatus): string;
-}
-export declare const backgroundTaskManager: BackgroundTaskManager;
-export {};

package/dist/core/batch-processor.d.ts

@@ -1,62 +0,0 @@
-/**
- * Smart Batch Processor - Centralized validation and retry
- *
- * Strategy: Execute all tasks → Centralized validation → Retry only failures
- * This is more efficient than naive parallelism because:
- * 1. Failed tasks are batch-identified and retried
- * 2. No redundant work on already-successful tasks
- * 3. Validation happens once, not per-task
- */
-import type { ParallelAgentManager } from "./async-agent.js";
-export interface BatchTask {
-    id: string;
-    description: string;
-    agent: string;
-    prompt: string;
-    status: 'pending' | 'success' | 'failed' | 'retrying';
-    attempts: number;
-    error?: string;
-}
-export interface BatchResult {
-    total: number;
-    success: number;
-    failed: number;
-    retried: number;
-    duration: number;
-    tasks: BatchTask[];
-}
-export interface BatchProcessorOptions {
-    concurrency: number;
-    maxRetries: number;
-    validateAfterEach?: boolean;
-    continueOnError?: boolean;
-}
-export declare class SmartBatchProcessor {
-    private parallelAgentManager;
-    private tasks;
-    constructor(parallelAgentManager: ParallelAgentManager);
-    /**
-     * Process a batch of tasks with smart validation
-     */
-    processBatch(tasks: BatchTask[], options?: BatchProcessorOptions): Promise<BatchResult>;
-    /**
-     * Execute a phase with concurrency control
-     */
-    private executePhase;
-    /**
-     * Execute a single task
-     */
-    private executeTask;
-    /**
-     * Build result summary
-     */
-    private buildResult;
-    /**
-     * Export failed tasks for manual review
-     */
-    exportFailedTasks(): string;
-    /**
-     * Clear all tasks
-     */
-    clear(): void;
-}

package/dist/core/config.d.ts

@@ -1,55 +0,0 @@
-/**
- * OpenCode Orchestrator Configuration
- *
- * Dynamic configuration with environment variable support and validation.
- * Priority: Environment Variables > Config File > Defaults
- */
-export interface ParallelAgentConfig {
-    taskTtlMs: number;
-    cleanupDelayMs: number;
-    minStabilityMs: number;
-    pollIntervalMs: number;
-    defaultConcurrency: number;
-    maxConcurrency: number;
-    enableDebug: boolean;
-    enableDetailedLogs: boolean;
-}
-export interface BackgroundTaskConfig {
-    monitorIntervalMs: number;
-    storageDir: string;
-    defaultTimeoutMs: number;
-    maxCompletedTasksToKeep: number;
-    enableDebug: boolean;
-}
-export interface SessionConfig {
-    defaultMaxSteps: number;
-    taskCommandMaxSteps: number;
-}
-declare class ConfigManager {
-    private static _instance;
-    private parallelAgentConfig;
-    private backgroundTaskConfig;
-    private sessionConfig;
-    private constructor();
-    static getInstance(): ConfigManager;
-    private loadParallelAgentConfig;
-    getParallelAgentConfig(): Readonly<ParallelAgentConfig>;
-    private loadBackgroundTaskConfig;
-    getBackgroundTaskConfig(): Readonly<BackgroundTaskConfig>;
-    private loadSessionConfig;
-    getSessionConfig(): Readonly<SessionConfig>;
-    /**
-     * Update configuration at runtime
-     * Useful for adaptive behavior or user preferences
-     */
-    updateParallelAgentConfig(updates: Partial<ParallelAgentConfig>): void;
-    updateBackgroundTaskConfig(updates: Partial<BackgroundTaskConfig>): void;
-    updateSessionConfig(updates: Partial<SessionConfig>): void;
-    private validateParallelAgentConfig;
-    private validateBackgroundTaskConfig;
-    private validateSessionConfig;
-    private parseEnvInt;
-    exportConfigs(): void;
-}
-export declare const configManager: ConfigManager;
-export {};

package/dist/core/session-manager.d.ts

@@ -1,39 +0,0 @@
-export interface SessionEvents {
-    created: (sessionID: string) => void;
-    activated: (sessionID: string) => void;
-    deactivated: (sessionID: string, reason?: string) => void;
-    step: (sessionID: string, step: number) => void;
-    completed: (sessionID: string, result: any) => void;
-    error: (sessionID: string, error: Error) => void;
-    disposed: (sessionID: string) => void;
-}
-export interface SessionState {
-    active: boolean;
-    step: number;
-    maxSteps: number;
-    timestamp: number;
-    startTime: number;
-    lastStepTime: number;
-    eventQueue: Map<string, any[]>;
-}
-export interface SessionOptions {
-    maxSteps?: number;
-}
-export declare class SessionManager {
-    private sessions;
-    private events;
-    on(event: keyof SessionEvents, handler: SessionEvents[keyof SessionEvents]): void;
-    emit(event: keyof SessionEvents, sessionID: string, data?: any): void;
-    create(sessionID: string, options?: SessionOptions): SessionState;
-    activate(sessionID: string): void;
-    deactivate(sessionID: string, reason?: string): void;
-    step(sessionID: string): void;
-    complete(sessionID: string, result: any): void;
-    error(sessionID: string, error: Error): void;
-    dispose(sessionID: string): void;
-    get(sessionID: string): SessionState | undefined;
-    isActive(sessionID: string): boolean;
-    getAll(): SessionState[];
-    cleanupInactive(maxAgeMs: number): number;
-}
-export declare const sessionManager: SessionManager;

package/dist/parallel/optimizer.d.ts

@@ -1,47 +0,0 @@
-/**
- * Auto-Parallel Optimizer
- *
- * Optimizes task parallelization by analyzing dependencies and conflicts.
- * Maximizes parallel execution while preventing conflicts.
- */
-import type { Task } from "../core/tasks.js";
-export interface OptimizationResult {
-    tasks: Task[];
-    groups: Map<number, string[]>;
-    efficiency: number;
-    optimizationNotes: string[];
-}
-/**
- * Auto-Parallel Optimizer analyzes tasks and creates optimal parallel groups
- */
-export declare class ParallelOptimizer {
-    /**
-     * Optimize tasks for parallel execution
-     */
-    optimize(tasks: Task[]): OptimizationResult;
-    /**
-     * Check if task dependencies are satisfied
-     */
-    private areDependenciesSatisfied;
-    /**
-     * Format optimization result for display
-     */
-    formatResult(result: OptimizationResult): string;
-    /**
-     * Get conflict analysis
-     */
-    analyzeConflicts(tasks: Task[]): Map<string, string[]>;
-    /**
-     * Suggest task reordering for better parallelism
-     */
-    suggestReordering(tasks: Task[]): Task[];
-    /**
-     * Calculate parallelization potential
-     */
-    calculateParallelizationPotential(tasks: Task[]): {
-        current: number;
-        optimal: number;
-        improvement: number;
-    };
-}
-export declare const parallelOptimizer: ParallelOptimizer;

package/dist/profiler/execution.d.ts

@@ -1,40 +0,0 @@
-/**
- * Execution Profiler
- *
- * Tracks and analyzes agent performance metrics.
- * Provides data-driven optimization insights.
- */
-export interface Metric {
-    operation: string;
-    duration: number;
-    timestamp: number;
-    agent: string;
-    success: boolean;
-}
-export interface PerformanceMetrics {
-    agent: string;
-    operations: Metric[];
-    averageDuration: number;
-    medianDuration: number;
-    totalDuration: number;
-    operationCount: number;
-    successRate: number;
-}
-export interface Analysis {
-    performance: Record<string, PerformanceMetrics>;
-    outliers: Metric[];
-    suggestions: string[];
-    bottlenecks: string[];
-}
-export declare class ExecutionProfiler {
-    private metrics;
-    record(agent: string, operation: string, duration: number, success?: boolean): void;
-    getMetrics(agent: string): Metric[];
-    analyze(agent: string): PerformanceMetrics;
-    analyzeAll(): Analysis;
-    formatAnalysis(analysis: Analysis): string;
-    clear(): void;
-    toJSON(): string;
-    static fromJSON(json: string): ExecutionProfiler;
-}
-export declare const executionProfiler: ExecutionProfiler;

package/dist/prompts/shared.d.ts

@@ -1,2 +0,0 @@
-export { REASONING_CONSTRAINTS, LANGUAGE_RULE, TASK_COMPLETION_CHECK, OUTPUT_FORMAT, ANTI_PATTERNS, WORKFLOW, BASE_PROMPT, } from "../constants/prompts.js";
-export { RECOVERY_PROMPT, ESCALATION_PROMPT } from "../utils/sanity.js";

package/dist/shared/contracts/interfaces.d.ts

@@ -1,7 +0,0 @@
-export interface AgentDefinition {
-    id: string;
-    description: string;
-    systemPrompt: string;
-    canWrite: boolean;
-    canBash: boolean;
-}

package/dist/tasks.d.ts

@@ -1,29 +0,0 @@
-/**
- * Task management for DAG-based orchestration
- */
-export type TaskStatus = "pending" | "running" | "completed" | "failed";
-export interface Task {
-    id: string;
-    description: string;
-    action: string;
-    file: string;
-    dependencies: string[];
-    status: TaskStatus;
-    result?: string;
-    retryCount: number;
-    complexity: number;
-    type: "infrastructure" | "logic" | "integration";
-}
-export declare class TaskGraph {
-    private tasks;
-    constructor(tasks?: Task[]);
-    addTask(task: Task): void;
-    getTask(id: string): Task | undefined;
-    updateTask(id: string, updates: Partial<Task>): void;
-    getReadyTasks(): Task[];
-    isCompleted(): boolean;
-    hasFailed(): boolean;
-    getTaskSummary(): string;
-    toJSON(): string;
-    static fromJSON(json: string): TaskGraph;
-}

package/dist/tools/async-agent.d.ts

@@ -1,70 +0,0 @@
-/**
- * Task Delegation Tools
- *
- * Tools for delegating work to agents:
- * - delegate_task: Delegate work to an agent (sync or background)
- * - get_task_result: Retrieve completed task result
- * - list_tasks: View all parallel tasks
- * - cancel_task: Stop a running task
- */
-import { type ToolDefinition } from "@opencode-ai/plugin";
-import { ParallelAgentManager } from "../core/async-agent.js";
-export { ParallelAgentManager as AsyncAgentManager } from "../core/async-agent.js";
-/**
- * delegate_task - Delegate work to an agent (sync or background)
- */
-export declare const createDelegateTaskTool: (manager: ParallelAgentManager, client: unknown) => {
-    description: string;
-    args: {
-        agent: import("zod").ZodString;
-        description: import("zod").ZodString;
-        prompt: import("zod").ZodString;
-        background: import("zod").ZodBoolean;
-    };
-    execute(args: {
-        agent: string;
-        description: string;
-        prompt: string;
-        background: boolean;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * get_task_result - Get result from a completed background task
- */
-export declare const createGetTaskResultTool: (manager: ParallelAgentManager) => {
-    description: string;
-    args: {
-        taskId: import("zod").ZodString;
-    };
-    execute(args: {
-        taskId: string;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * list_tasks - List all background tasks
- */
-export declare const createListTasksTool: (manager: ParallelAgentManager) => {
-    description: string;
-    args: {
-        status: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        status?: string | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * cancel_task - Cancel a running background task
- */
-export declare const createCancelTaskTool: (manager: ParallelAgentManager) => {
-    description: string;
-    args: {
-        taskId: import("zod").ZodString;
-    };
-    execute(args: {
-        taskId: string;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * Factory function to create all task delegation tools
- */
-export declare function createAsyncAgentTools(manager: ParallelAgentManager, client?: unknown): Record<string, ToolDefinition>;

package/dist/tools/background.d.ts

@@ -1,55 +0,0 @@
-/**
- * Background Task Tools for OpenCode Orchestrator
- *
- * These tools allow the AI to run commands in the background and check their results later.
- * This is useful for long-running builds, tests, or other operations.
- */
-export declare const runBackgroundTool: {
-    description: string;
-    args: {
-        command: import("zod").ZodString;
-        cwd: import("zod").ZodOptional<import("zod").ZodString>;
-        timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
-        label: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        command: string;
-        cwd?: string | undefined;
-        timeout?: number | undefined;
-        label?: string | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-export declare const checkBackgroundTool: {
-    description: string;
-    args: {
-        taskId: import("zod").ZodString;
-        tailLines: import("zod").ZodOptional<import("zod").ZodNumber>;
-    };
-    execute(args: {
-        taskId: string;
-        tailLines?: number | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-export declare const listBackgroundTool: {
-    description: string;
-    args: {
-        status: import("zod").ZodOptional<import("zod").ZodEnum<{
-            running: "running";
-            done: "done";
-            error: "error";
-            all: "all";
-        }>>;
-    };
-    execute(args: {
-        status?: "running" | "done" | "error" | "all" | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-export declare const killBackgroundTool: {
-    description: string;
-    args: {
-        taskId: import("zod").ZodString;
-    };
-    execute(args: {
-        taskId: string;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};

package/dist/tools/batch.d.ts

@@ -1,53 +0,0 @@
-/**
- * Smart Batch Tool - Centralized validation and retry
- *
- * Execute many tasks with intelligent batching, validation, and retry.
- */
-import { tool } from "@opencode-ai/plugin";
-import { ParallelAgentManager } from "../core/async-agent.js";
-/**
- * process_batch - Execute multiple tasks with smart validation
- */
-export declare const createProcessBatchTool: (parallelAgentManager: ParallelAgentManager, client: unknown) => {
-    description: string;
-    args: {
-        concurrency: import("zod").ZodString;
-        maxRetries: import("zod").ZodOptional<import("zod").ZodString>;
-        validateAfterEach: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        tasks: import("zod").ZodString;
-    };
-    execute(args: {
-        concurrency: string;
-        tasks: string;
-        maxRetries?: string | undefined;
-        validateAfterEach?: boolean | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * export_failed_tasks - Export failed tasks for manual review
- */
-export declare const createExportFailedTasksTool: (parallelAgentManager: ParallelAgentManager) => {
-    description: string;
-    args: {};
-    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * compare_strategies - Compare performance of different strategies
- */
-export declare const createCompareStrategiesTool: (parallelAgentManager: ParallelAgentManager) => {
-    description: string;
-    args: {
-        taskCount: import("zod").ZodString;
-        concurrency1: import("zod").ZodOptional<import("zod").ZodString>;
-        concurrency2: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        taskCount: string;
-        concurrency1?: string | undefined;
-        concurrency2?: string | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};
-/**
- * Factory to create all batch tools
- */
-export declare function createBatchTools(parallelAgentManager: ParallelAgentManager, client?: unknown): Record<string, ReturnType<typeof tool>>;