opencode-orchestrator 0.5.4 → 0.5.5

package/dist/agents/definitions.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../shared/agent.js";
 export declare const AGENTS: Record<string, AgentDefinition>;

package/dist/agents/orchestrator.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../shared/agent.js";
 export declare const orchestrator: AgentDefinition;

package/dist/agents/subagents/architect.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const architect: AgentDefinition;

package/dist/agents/subagents/builder.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const builder: AgentDefinition;

package/dist/agents/subagents/inspector.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const inspector: AgentDefinition;

package/dist/agents/subagents/recorder.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const recorder: AgentDefinition;

package/dist/core/agents/concurrency.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Concurrency Controller
+ *
+ * Queue-based rate limiting with support for:
+ * - Agent-specific limits
+ * - Provider-specific limits (e.g., anthropic/*, openai/*)
+ * - Model-specific limits (e.g., anthropic/claude-3-5-sonnet)
+ */
+export interface ConcurrencyConfig {
+    defaultConcurrency?: number;
+    agentConcurrency?: Record<string, number>;
+    providerConcurrency?: Record<string, number>;
+    modelConcurrency?: Record<string, number>;
+}
+export declare class ConcurrencyController {
+    private counts;
+    private queues;
+    private limits;
+    private config;
+    constructor(config?: ConcurrencyConfig);
+    setLimit(key: string, limit: number): void;
+    /**
+     * Get concurrency limit for a key.
+     * Priority: explicit limit > model > provider > agent > default
+     */
+    getConcurrencyLimit(key: string): number;
+    getLimit(key: string): number;
+    acquire(key: string): Promise<void>;
+    release(key: string): void;
+    getQueueLength(key: string): number;
+    getActiveCount(key: string): number;
+    /**
+     * Get formatted concurrency info string (e.g., "2/5 slots")
+     */
+    getConcurrencyInfo(key: string): string;
+}

package/dist/core/agents/config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parallel Manager Configuration
+ */
+export declare const CONFIG: {
+    readonly TASK_TTL_MS: number;
+    readonly CLEANUP_DELAY_MS: number;
+    readonly MIN_STABILITY_MS: number;
+    readonly POLL_INTERVAL_MS: 2000;
+};

package/dist/core/agents/format.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Format utilities for parallel tasks
+ */
+export declare function formatDuration(start: Date, end?: Date): string;
+export declare function buildNotificationMessage(tasks: Array<{
+    id: string;
+    description: string;
+    status: string;
+}>): string;

package/dist/core/agents/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parallel Module - Agent parallel execution
+ */
+export * from "./types/index.js";
+export * from "./interfaces/index.js";
+export { ConcurrencyController } from "./concurrency.js";
+export { ParallelAgentManager, parallelAgentManager } from "./manager.js";

package/dist/core/agents/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Parallel Module Interfaces Index
+ */
+export { ParallelTask } from "./parallel-task.js";
+export { LaunchInput } from "./launch-input.js";

package/dist/core/agents/interfaces/launch-input.d.ts

@@ -0,0 +1,9 @@
+/**
+ * LaunchInput - Input for launching a parallel task
+ */
+export interface LaunchInput {
+    description: string;
+    prompt: string;
+    agent: string;
+    parentSessionID: string;
+}

package/dist/core/agents/interfaces/parallel-task.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ParallelTask - Represents a task running in a parallel session
+ */
+import { ParallelTaskStatus } from "../types/parallel-task-status.js";
+export interface TaskProgress {
+    toolCalls: number;
+    lastTool?: string;
+    lastMessage?: string;
+    lastUpdate: Date;
+}
+export interface ParallelTask {
+    id: string;
+    sessionID: string;
+    parentSessionID: string;
+    description: string;
+    agent: string;
+    status: ParallelTaskStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    error?: string;
+    result?: string;
+    concurrencyKey?: string;
+    lastMsgCount?: number;
+    stablePolls?: number;
+    progress?: TaskProgress;
+}

package/dist/core/agents/logger.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Debug logger for parallel agent
+ */
+export declare function log(...args: unknown[]): void;

package/dist/core/agents/manager.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Parallel Agent Manager
+ *
+ * Session-based async agent execution with:
+ * - Concurrency control per agent type
+ * - Batched notifications
+ * - Automatic cleanup
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import { formatDuration } from "./format.js";
+import type { ParallelTask } from "./interfaces/parallel-task.js";
+import type { LaunchInput } from "./interfaces/launch-input.js";
+export type { ParallelTask };
+export { formatDuration };
+type OpencodeClient = PluginInput["client"];
+export declare class ParallelAgentManager {
+    private static _instance;
+    private store;
+    private client;
+    private directory;
+    private concurrency;
+    private pollingInterval?;
+    private constructor();
+    static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
+    launch(input: LaunchInput): Promise<ParallelTask>;
+    getTask(id: string): ParallelTask | undefined;
+    getRunningTasks(): ParallelTask[];
+    getAllTasks(): ParallelTask[];
+    getTasksByParent(parentSessionID: string): ParallelTask[];
+    cancelTask(taskId: string): Promise<boolean>;
+    getResult(taskId: string): Promise<string | null>;
+    setConcurrencyLimit(agentType: string, limit: number): void;
+    getPendingCount(parentSessionID: string): number;
+    cleanup(): void;
+    formatDuration: typeof formatDuration;
+    /**
+     * Handle OpenCode session events for proper resource cleanup.
+     * Call this from your plugin's event hook.
+     */
+    handleEvent(event: {
+        type: string;
+        properties?: {
+            sessionID?: string;
+            info?: {
+                id?: string;
+            };
+        };
+    }): void;
+    /**
+     * Find task by session ID
+     */
+    private findBySession;
+    /**
+     * Handle session.idle event - validate and complete task
+     */
+    private handleSessionIdle;
+    private handleTaskError;
+    private startPolling;
+    private stopPolling;
+    private pollRunningTasks;
+    /**
+     * Update task progress and stability tracking
+     */
+    private updateTaskProgress;
+    /**
+     * Complete a task and cleanup
+     */
+    private completeTask;
+    private validateSessionHasOutput;
+    private pruneExpiredTasks;
+    private scheduleCleanup;
+    private notifyParentIfAllComplete;
+}
+export declare const parallelAgentManager: {
+    getInstance: typeof ParallelAgentManager.getInstance;
+};

package/dist/core/agents/task-store.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Task Store - Stores and manages parallel tasks
+ */
+import type { ParallelTask } from "./interfaces/parallel-task.js";
+export declare class TaskStore {
+    private tasks;
+    private pendingByParent;
+    private notifications;
+    set(id: string, task: ParallelTask): void;
+    get(id: string): ParallelTask | undefined;
+    getAll(): ParallelTask[];
+    getRunning(): ParallelTask[];
+    getByParent(parentSessionID: string): ParallelTask[];
+    delete(id: string): boolean;
+    clear(): void;
+    trackPending(parentSessionID: string, taskId: string): void;
+    untrackPending(parentSessionID: string, taskId: string): void;
+    getPendingCount(parentSessionID: string): number;
+    hasPending(parentSessionID: string): boolean;
+    queueNotification(task: ParallelTask): void;
+    getNotifications(parentSessionID: string): ParallelTask[];
+    clearNotifications(parentSessionID: string): void;
+    cleanEmptyNotifications(): void;
+    /**
+     * Remove a specific task from all notification queues
+     */
+    clearNotificationsForTask(taskId: string): void;
+}

package/dist/core/agents/types/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parallel Module Types Index
+ */
+export { ParallelTaskStatus } from "./parallel-task-status.js";

package/dist/core/agents/types/parallel-task-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * ParallelTaskStatus - Task status union type
+ */
+export type ParallelTaskStatus = "pending" | "running" | "completed" | "error" | "timeout";

package/dist/core/commands/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Background Task Module
+ */
+export * from "./types/index.js";
+export * from "./interfaces/index.js";
+export { backgroundTaskManager } from "./manager.js";

package/dist/core/commands/interfaces/background-task.d.ts

@@ -0,0 +1,20 @@
+/**
+ * BackgroundTask - Represents a shell command running in background
+ */
+import { ChildProcess } from "child_process";
+import { BackgroundTaskStatus } from "../types/background-task-status.js";
+export interface BackgroundTask {
+    id: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    label?: string;
+    status: BackgroundTaskStatus;
+    output: string;
+    errorOutput: string;
+    exitCode: number | null;
+    startTime: number;
+    endTime?: number;
+    timeout: number;
+    process?: ChildProcess;
+}

package/dist/core/commands/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Background Task Interfaces Index
+ */
+export { BackgroundTask } from "./background-task.js";
+export { RunBackgroundOptions } from "./run-background-options.js";

package/dist/core/commands/interfaces/run-background-options.d.ts

@@ -0,0 +1,9 @@
+/**
+ * RunBackgroundOptions - Options for running a background task
+ */
+export interface RunBackgroundOptions {
+    command: string;
+    cwd?: string;
+    timeout?: number;
+    label?: string;
+}

package/dist/core/commands/manager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Background Task Manager
+ *
+ * Runs shell commands in the background and tracks their output.
+ */
+import type { BackgroundTask } from "./interfaces/background-task.js";
+import type { BackgroundTaskStatus } from "./types/background-task-status.js";
+import type { RunBackgroundOptions } from "./interfaces/run-background-options.js";
+declare class BackgroundTaskManager {
+    private static _instance;
+    private tasks;
+    private debugMode;
+    private constructor();
+    static get instance(): BackgroundTaskManager;
+    private generateId;
+    private debug;
+    run(options: RunBackgroundOptions): BackgroundTask;
+    get(taskId: string): BackgroundTask | undefined;
+    getAll(): BackgroundTask[];
+    getByStatus(status: BackgroundTaskStatus): BackgroundTask[];
+    clearCompleted(): number;
+    kill(taskId: string): boolean;
+    formatDuration(task: BackgroundTask): string;
+    getStatusEmoji(status: BackgroundTaskStatus): string;
+}
+export declare const backgroundTaskManager: BackgroundTaskManager;
+export {};

package/dist/core/commands/types/background-task-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * BackgroundTaskStatus - Task status union type
+ */
+export type BackgroundTaskStatus = "pending" | "running" | "done" | "error" | "timeout";

package/dist/core/commands/types/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Background Task Types Index
+ */
+export { BackgroundTaskStatus } from "./background-task-status.js";

package/dist/core/orchestrator/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Session Module - State and Task management
+ */
+export * from "./types/index.js";
+export * from "./interfaces/index.js";
+export { TaskGraph } from "./task-graph.js";
+export { state } from "./state.js";

package/dist/core/orchestrator/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Session Interfaces Index
+ */
+export { Task } from "./task.js";
+export { SessionState } from "./session-state.js";

package/dist/core/{state.d.ts → orchestrator/interfaces/session-state.d.ts}

@@ -1,4 +1,7 @@
-import { TaskGraph } from "./tasks.js";
+/**
+ * SessionState - State for a single orchestration session
+ */
+import type { TaskGraph } from "../task-graph.js";
 export interface SessionState {
     enabled: boolean;
     iterations: number;
@@ -8,9 +11,3 @@ export interface SessionState {
     anomalyCount: number;
     lastHealthyOutput?: string;
 }
-export declare const state: {
-    missionActive: boolean;
-    maxIterations: number;
-    maxRetries: number;
-    sessions: Map<string, SessionState>;
-};

package/dist/core/orchestrator/interfaces/task.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Task - A single task in the orchestration DAG
+ */
+import { TaskStatus } from "../types/task-status.js";
+import { TaskType } from "../types/task-type.js";
+export interface Task {
+    id: string;
+    description: string;
+    action: string;
+    file: string;
+    dependencies: string[];
+    status: TaskStatus;
+    result?: string;
+    retryCount: number;
+    complexity: number;
+    type: TaskType;
+}

package/dist/core/orchestrator/state.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Global State - Orchestration state manager
+ */
+import { SessionState } from "./interfaces/session-state.js";
+export declare const state: {
+    missionActive: boolean;
+    maxIterations: number;
+    maxRetries: number;
+    sessions: Map<string, SessionState>;
+};

package/dist/core/{tasks.d.ts → orchestrator/task-graph.d.ts}

@@ -1,19 +1,7 @@
 /**
- * Task management for DAG-based orchestration
+ * TaskGraph - DAG for task 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";
-}
+import { Task } from "./interfaces/task.js";
 export declare class TaskGraph {
     private tasks;
     constructor(tasks?: Task[]);

package/dist/core/orchestrator/types/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Orchestrator Types Index
+ */
+export { TaskStatus } from "./task-status.js";
+export { TaskType } from "./task-type.js";

package/dist/core/orchestrator/types/task-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * TaskStatus - Status of a task in the DAG
+ */
+export type TaskStatus = "pending" | "running" | "completed" | "failed";

package/dist/core/orchestrator/types/task-type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * TaskType - Type of task in the orchestration DAG
+ */
+export type TaskType = "infrastructure" | "logic" | "integration";

package/dist/index.d.ts

@@ -67,12 +67,10 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
             args: {
                 patterns: import("zod").ZodArray<import("zod").ZodString>;
                 dir: import("zod").ZodOptional<import("zod").ZodString>;
-                max_results_per_pattern: import("zod").ZodOptional<import("zod").ZodNumber>;
             };
             execute(args: {
                 patterns: string[];
                 dir?: string | undefined;
-                max_results_per_pattern?: number | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
         run_background: {