opencode-orchestrator 0.5.16 → 0.5.18

package/dist/core/notification/toast-core.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Toast Core - Core notification functions
+ */
+import type { ToastMessage, ToastOptions } from "./types.js";
+/**
+ * Register a notification handler
+ */
+export declare function onToast(handler: (toast: ToastMessage) => void): () => void;
+/**
+ * Show a toast notification
+ */
+export declare function show(options: ToastOptions): ToastMessage;
+/**
+ * Dismiss a toast
+ */
+export declare function dismiss(toastId: string): void;
+/**
+ * Get active (non-dismissed) toasts
+ */
+export declare function getActive(): ToastMessage[];
+/**
+ * Get toast history
+ */
+export declare function getHistory(limit?: number): ToastMessage[];
+/**
+ * Clear all toasts
+ */
+export declare function clear(): void;

package/dist/core/notification/toast.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Toast Notification System
+ *
+ * Provides notifications for task events, completions, errors
+ */
+export type { ToastVariant, ToastMessage, ToastOptions } from "./types.js";
+export { show, dismiss, getActive, getHistory, clear, onToast } from "./toast-core.js";
+export { presets } from "./presets.js";
+export { enableAutoToasts } from "./event-integration.js";

package/dist/core/notification/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Toast Types
+ */
+export type ToastVariant = "info" | "success" | "warning" | "error";
+export interface ToastMessage {
+    id: string;
+    title: string;
+    message: string;
+    variant: ToastVariant;
+    timestamp: Date;
+    duration: number;
+    dismissed: boolean;
+}
+export interface ToastOptions {
+    title: string;
+    message: string;
+    variant?: ToastVariant;
+    duration?: number;
+}

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

@@ -1,4 +1,4 @@
 /**
- * TaskStatus - Status of a task in the DAG
+ * Task Status - Re-export from central location
  */
-export type TaskStatus = "pending" | "running" | "completed" | "failed";
+export { TASK_STATUS, ParallelTaskStatus as TaskStatus } from "../../../shared/constants.js";

package/dist/core/progress/calculator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Progress Calculator - Rate and estimation calculations
+ */
+/**
+ * Calculate rate (items per minute)
+ */
+export declare function calculateRate(sessionId: string): number;
+/**
+ * Estimate remaining time in ms
+ */
+export declare function estimateRemaining(sessionId: string): number | undefined;

package/dist/core/progress/formatters.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Progress Formatting Utilities
+ */
+import type { ProgressSnapshot } from "./interfaces.js";
+/**
+ * Format elapsed time
+ */
+export declare function formatElapsed(ms: number): string;
+/**
+ * Format progress bar
+ */
+export declare function formatProgressBar(percentage: number, width?: number): string;
+/**
+ * Get formatted progress string
+ */
+export declare function formatSnapshot(snapshot: ProgressSnapshot): string;
+/**
+ * Get compact progress string (for inline display)
+ */
+export declare function formatCompact(snapshot: ProgressSnapshot): string;

package/dist/core/progress/interfaces.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Progress Tracker Interfaces
+ */
+/**
+ * Todo progress data
+ */
+export interface TodoProgress {
+    total: number;
+    completed: number;
+    pending: number;
+    percentage: number;
+}
+/**
+ * Task progress data
+ */
+export interface TaskProgress {
+    total: number;
+    running: number;
+    completed: number;
+    failed: number;
+    percentage: number;
+}
+/**
+ * Step progress data
+ */
+export interface StepProgress {
+    current: number;
+    max: number;
+}
+/**
+ * Progress snapshot at a point in time
+ */
+export interface ProgressSnapshot {
+    sessionId: string;
+    timestamp: Date;
+    todos: TodoProgress;
+    tasks: TaskProgress;
+    steps: StepProgress;
+    startedAt: Date;
+    elapsedMs: number;
+}
+/**
+ * Input data for recording a snapshot
+ */
+export interface SnapshotInput {
+    todoTotal?: number;
+    todoCompleted?: number;
+    taskTotal?: number;
+    taskRunning?: number;
+    taskCompleted?: number;
+    taskFailed?: number;
+    currentStep?: number;
+    maxSteps?: number;
+}

package/dist/core/progress/store.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Progress Store - Session data management
+ */
+import type { ProgressSnapshot, SnapshotInput } from "./interfaces.js";
+/**
+ * Start tracking a session
+ */
+export declare function startSession(sessionId: string): void;
+/**
+ * Get session start time
+ */
+export declare function getSessionStart(sessionId: string): Date | undefined;
+/**
+ * Record a progress snapshot
+ */
+export declare function recordSnapshot(sessionId: string, data: SnapshotInput): ProgressSnapshot;
+/**
+ * Get latest snapshot
+ */
+export declare function getLatest(sessionId: string): ProgressSnapshot | undefined;
+/**
+ * Get progress history
+ */
+export declare function getHistory(sessionId: string, limit?: number): ProgressSnapshot[];
+/**
+ * Clear session data
+ */
+export declare function clearSession(sessionId: string): void;

package/dist/core/progress/tracker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Progress Tracker Module
+ *
+ * Tracks progress of sessions, tasks, and todos
+ */
+export type { TodoProgress, TaskProgress, StepProgress, ProgressSnapshot, SnapshotInput, } from "./interfaces.js";
+export { startSession, getSessionStart, recordSnapshot, getLatest, getHistory, clearSession, } from "./store.js";
+export { formatElapsed, formatProgressBar, formatSnapshot, } from "./formatters.js";
+export { calculateRate, estimateRemaining, } from "./calculator.js";
+export declare function format(sessionId: string): string;
+export declare function formatCompact(sessionId: string): string;

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

@@ -0,0 +1,46 @@
+/**
+ * AsyncQueue - Async iterable queue
+ *
+ * Useful for producer/consumer patterns
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private closed;
+    /**
+     * Push an item to the queue
+     */
+    push(item: T): void;
+    /**
+     * Get the next item (blocks if empty)
+     */
+    next(): Promise<T>;
+    /**
+     * Try to get an item without blocking
+     */
+    tryNext(): T | undefined;
+    /**
+     * Check if queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Get current queue length
+     */
+    get length(): number;
+    /**
+     * Close the queue (no more items can be added)
+     */
+    close(): void;
+    /**
+     * Check if queue is closed
+     */
+    isClosed(): boolean;
+    /**
+     * Clear all items
+     */
+    clear(): void;
+    /**
+     * Async iterator support
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<T, void, unknown>;
+}

package/dist/core/queue/async-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Async Utilities - Retry, timeout, debounce
+ */
+/**
+ * Retry with exponential backoff
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffFactor?: number;
+}): Promise<T>;
+/**
+ * Timeout wrapper
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string): Promise<T>;
+/**
+ * Debounce async function
+ */
+export declare function debounceAsync<T extends (...args: any[]) => Promise<any>>(fn: T, delayMs: number): T;

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

@@ -0,0 +1,8 @@
+/**
+ * AsyncQueue & Work Pool
+ *
+ * Utilities for async iteration and concurrent work processing
+ */
+export { AsyncQueue } from "./async-queue.js";
+export { workPool, workPoolWithResults, processBatches } from "./work-pool.js";
+export { retryWithBackoff, withTimeout, debounceAsync } from "./async-utils.js";

package/dist/core/queue/work-pool.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Work Pool - Concurrent task execution utilities
+ */
+/**
+ * Work Pool - Concurrent task execution with limit
+ *
+ * @param concurrency - Maximum concurrent tasks
+ * @param items - Items to process
+ * @param fn - Processing function
+ */
+export declare function workPool<T>(concurrency: number, items: T[], fn: (item: T, index: number) => Promise<void>): Promise<void>;
+/**
+ * Work Pool with results - Returns results in order
+ */
+export declare function workPoolWithResults<T, R>(concurrency: number, items: T[], fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/**
+ * Batch processing - Process items in batches
+ */
+export declare function processBatches<T, R>(items: T[], batchSize: number, fn: (batch: T[]) => Promise<R[]>): Promise<R[]>;

package/dist/core/recovery/auto-recovery.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auto Recovery System
+ *
+ * Automatically handles and recovers from common errors
+ */
+export type { RecoveryAction, ErrorContext, ErrorPattern, RecoveryRecord, RecoveryStats, } from "./interfaces.js";
+export { MAX_RETRIES, BASE_DELAY, MAX_HISTORY } from "./constants.js";
+export { errorPatterns } from "./patterns.js";
+export { handleError, withRecovery, getStats, getHistory, clearSession, } from "./handler.js";

package/dist/core/recovery/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Recovery Constants
+ */
+export declare const MAX_RETRIES = 3;
+export declare const BASE_DELAY = 1000;
+export declare const MAX_HISTORY = 100;

package/dist/core/recovery/handler.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Recovery Handler - Core error handling logic
+ */
+import type { ErrorContext, RecoveryAction, RecoveryRecord, RecoveryStats } from "./interfaces.js";
+/**
+ * Handle an error and determine recovery action
+ */
+export declare function handleError(context: ErrorContext): RecoveryAction;
+/**
+ * Execute a function with auto-recovery
+ */
+export declare function withRecovery<T>(sessionId: string, fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    onRetry?: (action: RecoveryAction) => void;
+}): Promise<T>;
+/**
+ * Get recovery statistics
+ */
+export declare function getStats(): RecoveryStats;
+/**
+ * Get recent recovery history
+ */
+export declare function getHistory(limit?: number): RecoveryRecord[];
+/**
+ * Clear error counts for a session
+ */
+export declare function clearSession(sessionId: string): void;

package/dist/core/recovery/interfaces.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Auto Recovery Interfaces & Types
+ */
+/**
+ * Recovery action types
+ */
+export type RecoveryAction = {
+    type: "retry";
+    delay: number;
+    attempt: number;
+} | {
+    type: "skip";
+    reason: string;
+} | {
+    type: "escalate";
+    to: string;
+    reason: string;
+} | {
+    type: "resume";
+    sessionId: string;
+} | {
+    type: "compact";
+    reason: string;
+} | {
+    type: "abort";
+    reason: string;
+};
+/**
+ * Error context for recovery
+ */
+export interface ErrorContext {
+    sessionId: string;
+    taskId?: string;
+    agent?: string;
+    error: Error;
+    attempt: number;
+    timestamp: Date;
+}
+/**
+ * Error pattern definition
+ */
+export interface ErrorPattern {
+    pattern: RegExp | string;
+    category: string;
+    handler: (context: ErrorContext) => RecoveryAction;
+}
+/**
+ * Recovery history entry
+ */
+export interface RecoveryRecord {
+    context: ErrorContext;
+    action: RecoveryAction;
+    timestamp: Date;
+}
+/**
+ * Recovery statistics
+ */
+export interface RecoveryStats {
+    totalRecoveries: number;
+    byCategory: Record<string, number>;
+    byAction: Record<string, number>;
+    successRate: number;
+}

package/dist/core/recovery/patterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Error Patterns - Recovery strategies for common errors
+ */
+import type { ErrorPattern } from "./interfaces.js";
+/**
+ * Error patterns and their recovery strategies
+ */
+export declare const errorPatterns: ErrorPattern[];

package/dist/core/session/interfaces.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared Context Interfaces
+ */
+/**
+ * Cached document reference
+ */
+export interface SharedDocument {
+    url: string;
+    filename: string;
+    title: string;
+    cachedAt: Date;
+}
+/**
+ * Research finding
+ */
+export interface SharedFinding {
+    id: string;
+    content: string;
+    source: string;
+    timestamp: Date;
+    category: "pattern" | "api" | "config" | "warning" | "decision";
+}
+/**
+ * Decision record
+ */
+export interface SharedDecision {
+    id: string;
+    question: string;
+    answer: string;
+    rationale: string;
+    decidedAt: Date;
+}
+/**
+ * Complete shared context
+ */
+export interface SharedContext {
+    sessionId: string;
+    parentId?: string;
+    documents: Map<string, SharedDocument>;
+    findings: SharedFinding[];
+    decisions: Map<string, SharedDecision>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Context statistics
+ */
+export interface ContextStats {
+    totalContexts: number;
+    totalDocuments: number;
+    totalFindings: number;
+    totalDecisions: number;
+}

package/dist/core/session/shared-context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Session Shared Context
+ *
+ * Enables context sharing between parent and child sessions
+ */
+export type { SharedDocument, SharedFinding, SharedDecision, SharedContext, ContextStats, } from "./interfaces.js";
+export { create, get, getMerged, addDocument, addFinding, addDecision, getChildren, clear, clearAll, getStats, } from "./store.js";
+export { getSummary } from "./summary.js";

package/dist/core/session/store.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Context Store - Session context data management
+ */
+import type { SharedContext, SharedDocument, SharedFinding, SharedDecision, ContextStats } from "./interfaces.js";
+/**
+ * Create a new shared context for a session
+ */
+export declare function create(sessionId: string, parentId?: string): SharedContext;
+/**
+ * Get shared context for a session
+ */
+export declare function get(sessionId: string): SharedContext | undefined;
+/**
+ * Get merged context (includes parent context)
+ */
+export declare function getMerged(sessionId: string): SharedContext | undefined;
+/**
+ * Add a document to the shared context
+ */
+export declare function addDocument(sessionId: string, doc: SharedDocument): void;
+/**
+ * Add a finding to the shared context
+ */
+export declare function addFinding(sessionId: string, finding: Omit<SharedFinding, "id" | "timestamp">): void;
+/**
+ * Record a decision
+ */
+export declare function addDecision(sessionId: string, decision: Omit<SharedDecision, "id" | "decidedAt">): void;
+/**
+ * Get all child session IDs
+ */
+export declare function getChildren(parentId: string): string[];
+/**
+ * Clear context for a session
+ */
+export declare function clear(sessionId: string): void;
+/**
+ * Clear all contexts
+ */
+export declare function clearAll(): void;
+/**
+ * Get stats
+ */
+export declare function getStats(): ContextStats;

package/dist/core/session/summary.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Context Summary - Generate prompt summaries
+ */
+/**
+ * Get context summary for injection into prompts
+ */
+export declare function getSummary(sessionId: string): string;

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

@@ -0,0 +1,54 @@
+/**
+ * Task Decomposer Interfaces
+ */
+import { TASK_STATUS, ParallelTaskStatus } from "../../shared/constants.js";
+export { TASK_STATUS };
+export type TaskStatus = ParallelTaskStatus;
+/**
+ * Single task node
+ */
+export interface TaskNode {
+    id: string;
+    description: string;
+    level: number;
+    parent?: string;
+    children: string[];
+    status: TaskStatus;
+    agent?: string;
+    parallelGroup?: string;
+    dependsOn: string[];
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: string;
+}
+/**
+ * Complete task hierarchy
+ */
+export interface TaskHierarchy {
+    rootId: string;
+    nodes: Map<string, TaskNode>;
+    parallelGroups: Map<string, string[]>;
+}
+/**
+ * Task progress statistics
+ */
+export interface TaskProgress {
+    total: number;
+    pending: number;
+    running: number;
+    completed: number;
+    failed: number;
+    percentage: number;
+}
+/**
+ * Task creation input
+ */
+export interface TaskInput {
+    description: string;
+    level: number;
+    parentId?: string;
+    agent?: string;
+    parallelGroup?: string;
+    dependsOn?: string[];
+}

package/dist/core/task/parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Task Parser - Parse hierarchy from Architect output
+ */
+import type { TaskHierarchy } from "./interfaces.js";
+/**
+ * Parse task hierarchy from text (Architect output)
+ */
+export declare function parseFromText(sessionId: string, text: string): TaskHierarchy;

package/dist/core/task/scheduler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Task Scheduler - Execution order and dependencies
+ */
+import type { TaskNode } from "./interfaces.js";
+/**
+ * Get next executable tasks (respecting dependencies)
+ */
+export declare function getNextTasks(sessionId: string): TaskNode[];
+/**
+ * Get parallel group tasks that can run together
+ */
+export declare function getParallelBatch(sessionId: string, groupId: string): TaskNode[];

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

@@ -0,0 +1,32 @@
+/**
+ * Task Store - Hierarchy data management
+ */
+import type { TaskNode, TaskHierarchy, TaskInput, TaskStatus, TaskProgress } from "./interfaces.js";
+/**
+ * Create a new task hierarchy
+ */
+export declare function create(sessionId: string, rootDescription: string): TaskHierarchy;
+/**
+ * Get hierarchy for session
+ */
+export declare function getHierarchy(sessionId: string): TaskHierarchy | undefined;
+/**
+ * Add a task node
+ */
+export declare function addTask(sessionId: string, task: TaskInput): TaskNode;
+/**
+ * Update task status
+ */
+export declare function updateStatus(sessionId: string, taskId: string, status: TaskStatus, result?: string): void;
+/**
+ * Clear hierarchy
+ */
+export declare function clear(sessionId: string): void;
+/**
+ * Check if all tasks are complete
+ */
+export declare function isComplete(sessionId: string): boolean;
+/**
+ * Get progress statistics
+ */
+export declare function getProgress(sessionId: string): TaskProgress;

package/dist/core/task/summary.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Task Summary - Generate prompt summaries
+ */
+/**
+ * Get hierarchy summary for prompts
+ */
+export declare function getSummary(sessionId: string): string;

package/dist/core/task/task-decomposer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Task Decomposer
+ *
+ * Automatically decomposes complex tasks into hierarchical subtasks
+ */
+export type { TaskStatus, TaskNode, TaskHierarchy, TaskProgress, TaskInput, } from "./interfaces.js";
+export { create, getHierarchy, addTask, updateStatus, clear, isComplete, getProgress, } from "./store.js";
+export { getNextTasks, getParallelBatch, } from "./scheduler.js";
+export { parseFromText } from "./parser.js";
+export { getSummary } from "./summary.js";