@plusplusoneplusplus/coc 1.0.0

package/node_modules/@plusplusoneplusplus/forge/dist/queue/repo-queue-registry.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * RepoQueueRegistry
+ *
+ * Manages multiple TaskQueueManager instances, one per repository.
+ * Provides registry-level operations and aggregated statistics.
+ *
+ * Features:
+ * - Lazy queue creation (getOrCreate pattern)
+ * - Repository path normalization
+ * - Event forwarding from individual queues
+ * - Aggregated stats across all repos
+ * - Memory cleanup for removed repos
+ *
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoQueueRegistry = void 0;
+const events_1 = require("events");
+const path = __importStar(require("path"));
+const task_queue_manager_1 = require("./task-queue-manager");
+/** Events forwarded from individual queues (with repo path prepended) */
+const FORWARDED_EVENTS = [
+    'change',
+    'taskAdded',
+    'taskRemoved',
+    'taskUpdated',
+    'taskStarted',
+    'taskCompleted',
+    'taskFailed',
+    'taskCancelled',
+    'paused',
+    'resumed',
+    'drain-started',
+    'drain-cancelled',
+];
+/** Registry-level event name mapping for forwarded queue events */
+const EVENT_NAME_MAP = {
+    'change': 'queueChange',
+};
+class RepoQueueRegistry extends events_1.EventEmitter {
+    constructor(defaultOptions = {}) {
+        super();
+        /** Map of normalized repo path → TaskQueueManager */
+        this.queues = new Map();
+        /** Map of normalized repo path → array of listener removal functions */
+        this.listenerCleanup = new Map();
+        this.defaultQueueOptions = defaultOptions;
+    }
+    // ========================================================================
+    // Core Operations
+    // ========================================================================
+    /**
+     * Get the queue manager for a repository. Creates a new queue if it doesn't exist.
+     * @param repoPath Absolute path to repository (will be normalized)
+     * @returns The TaskQueueManager instance for the repository
+     */
+    getQueueForRepo(repoPath) {
+        const normalized = this.normalizePath(repoPath);
+        const existing = this.queues.get(normalized);
+        if (existing) {
+            return existing;
+        }
+        const queue = new task_queue_manager_1.TaskQueueManager(this.defaultQueueOptions);
+        this.queues.set(normalized, queue);
+        this.setupQueueEventForwarding(normalized, queue);
+        this.emit('repoAdded', normalized);
+        return queue;
+    }
+    /**
+     * Check if a repository has a registered queue.
+     * @param repoPath Repository path to check (will be normalized)
+     */
+    hasRepo(repoPath) {
+        return this.queues.has(this.normalizePath(repoPath));
+    }
+    /**
+     * Remove a repository's queue and clean up resources.
+     * Does NOT call queue.reset() or queue.clear() - just removes the reference.
+     * @param repoPath Repository path to remove (will be normalized)
+     * @returns true if queue existed and was removed, false if not found
+     */
+    removeRepo(repoPath) {
+        const normalized = this.normalizePath(repoPath);
+        if (!this.queues.has(normalized)) {
+            return false;
+        }
+        this.removeEventForwarding(normalized);
+        this.queues.delete(normalized);
+        this.emit('repoRemoved', normalized);
+        return true;
+    }
+    /**
+     * Get all registered repository paths.
+     * @returns Array of normalized repository paths (in insertion order)
+     */
+    getAllRepos() {
+        return Array.from(this.queues.keys());
+    }
+    /**
+     * Get the internal map of all queues (shallow copy).
+     */
+    getAllQueues() {
+        return new Map(this.queues);
+    }
+    // ========================================================================
+    // Statistics
+    // ========================================================================
+    /**
+     * Get aggregated statistics across all repositories.
+     */
+    getStats() {
+        const byRepo = {};
+        const totals = {
+            queued: 0,
+            running: 0,
+            completed: 0,
+            failed: 0,
+            cancelled: 0,
+            total: 0,
+        };
+        for (const [repoPath, queue] of this.queues) {
+            const stats = queue.getStats();
+            byRepo[repoPath] = stats;
+            totals.queued += stats.queued;
+            totals.running += stats.running;
+            totals.completed += stats.completed;
+            totals.failed += stats.failed;
+            totals.cancelled += stats.cancelled;
+            totals.total += stats.total;
+        }
+        return {
+            repoCount: this.queues.size,
+            totals,
+            byRepo,
+        };
+    }
+    /**
+     * Get statistics for a specific repository.
+     * @param repoPath Repository path (will be normalized)
+     * @returns QueueStats object if queue exists, undefined if not
+     */
+    getRepoStats(repoPath) {
+        const queue = this.queues.get(this.normalizePath(repoPath));
+        return queue?.getStats();
+    }
+    // ========================================================================
+    // Lifecycle
+    // ========================================================================
+    /**
+     * Remove all repositories and clear the registry.
+     */
+    clear() {
+        for (const normalized of this.queues.keys()) {
+            this.removeEventForwarding(normalized);
+        }
+        this.queues.clear();
+        this.emit('cleared');
+    }
+    /**
+     * Clean up resources and prepare for shutdown.
+     */
+    dispose() {
+        this.clear();
+        this.removeAllListeners();
+    }
+    // ========================================================================
+    // Private Helpers
+    // ========================================================================
+    /**
+     * Normalize a repository path for consistent map keys.
+     */
+    normalizePath(repoPath) {
+        return path.resolve(repoPath);
+    }
+    /**
+     * Set up event forwarding from a queue to the registry.
+     */
+    setupQueueEventForwarding(repoPath, queue) {
+        const cleanups = [];
+        for (const eventName of FORWARDED_EVENTS) {
+            const registryEventName = EVENT_NAME_MAP[eventName] || eventName;
+            const handler = (...args) => {
+                this.emit(registryEventName, repoPath, ...args);
+            };
+            queue.on(eventName, handler);
+            cleanups.push(() => queue.removeListener(eventName, handler));
+        }
+        this.listenerCleanup.set(repoPath, cleanups);
+    }
+    /**
+     * Remove event forwarding for a queue.
+     */
+    removeEventForwarding(repoPath) {
+        const cleanups = this.listenerCleanup.get(repoPath);
+        if (cleanups) {
+            for (const cleanup of cleanups) {
+                cleanup();
+            }
+            this.listenerCleanup.delete(repoPath);
+        }
+    }
+}
+exports.RepoQueueRegistry = RepoQueueRegistry;
+//# sourceMappingURL=repo-queue-registry.js.map

package/node_modules/@plusplusoneplusplus/forge/dist/queue/repo-queue-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-queue-registry.js","sourceRoot":"","sources":["../../src/queue/repo-queue-registry.ts"],"names":[],"mappings":"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"}

package/node_modules/@plusplusoneplusplus/forge/dist/queue/task-queue-manager.d.ts

@@ -0,0 +1,402 @@
+/**
+ * TaskQueueManager
+ *
+ * Manages a queue of tasks with priority-based ordering.
+ * Provides operations for enqueue, dequeue, reorder, and queue control.
+ *
+ * Uses Node.js EventEmitter for cross-platform compatibility.
+ * In-memory storage only - queue resets when process restarts.
+ *
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+import { EventEmitter } from 'events';
+import { QueuedTask, QueueItem, CreateTaskInput, TaskUpdate, QueueStats, PauseReason, TaskQueueManagerOptions } from './types';
+/**
+ * Task queue manager for managing AI task execution queue
+ */
+export declare class TaskQueueManager extends EventEmitter {
+    /** Queue of pending tasks and pause markers (sorted by priority for tasks; markers at absolute positions) */
+    private queue;
+    /** Currently running tasks */
+    private running;
+    /** History of completed/failed/cancelled tasks */
+    private history;
+    /** Whether the queue is paused */
+    private paused;
+    /** Whether autopilot is paused */
+    private autopilotPaused;
+    /** Whether the queue is in drain mode (no new tasks accepted) */
+    private draining;
+    /** Callbacks waiting for the queue to become idle */
+    private idleResolvers;
+    /** Configuration options */
+    private readonly options;
+    /** Set of paused repository IDs */
+    private pausedRepos;
+    /** Per-repo pause reason (present when paused due to task failure). */
+    private pauseReasons;
+    /** Function to extract repo ID from a task (injected) */
+    private readonly getTaskRepoId?;
+    /** Optional function to classify a task as exclusive (for non-exclusive fast-path insertion) */
+    private readonly isExclusiveFn?;
+    constructor(options?: TaskQueueManagerOptions);
+    /**
+     * Add a task to the queue
+     * @param input Task input (without auto-generated fields)
+     * @returns The ID of the queued task
+     */
+    enqueue(input: CreateTaskInput): string;
+    /**
+     * Remove and return the next eligible item from the queue.
+     * Pause markers are returned (and consumed) when encountered in order.
+     * Frozen tasks and tasks from paused repos are skipped.
+     * @returns The next item, or undefined if queue is empty
+     */
+    dequeue(): QueueItem | undefined;
+    /**
+     * Get the next eligible item without removing it.
+     * Pause markers are returned when encountered in order.
+     * Skips frozen tasks, tasks from paused repos, and non-admitted
+     * exclusive tasks when autopilot is paused.
+     * @returns The next eligible item, or undefined if none available
+     */
+    peek(): QueueItem | undefined;
+    /**
+     * Get all tasks (queued + running + history)
+     */
+    getAll(): QueuedTask[];
+    /**
+     * Get all queue items in order, including pause markers.
+     */
+    getQueueItems(): Array<QueueItem>;
+    /**
+     * Get all queued tasks (waiting for execution, excluding pause markers)
+     */
+    getQueued(): QueuedTask[];
+    /**
+     * Get all running tasks
+     */
+    getRunning(): QueuedTask[];
+    /**
+     * Get completed tasks from history
+     */
+    getCompleted(): QueuedTask[];
+    /**
+     * Get failed tasks from history
+     */
+    getFailed(): QueuedTask[];
+    /**
+     * Get cancelled tasks from history
+     */
+    getCancelled(): QueuedTask[];
+    /**
+     * Get history (completed + failed + cancelled)
+     */
+    getHistory(): QueuedTask[];
+    /**
+     * Get the number of queued tasks (excludes pause markers)
+     */
+    size(): number;
+    /**
+     * Get queue statistics
+     */
+    getStats(): QueueStats;
+    /**
+     * Get a task by ID (searches all: queued, running, history)
+     */
+    getTask(id: string): QueuedTask | undefined;
+    /**
+     * Update a task's properties
+     * @param id Task ID
+     * @param updates Partial updates to apply
+     * @returns true if task was found and updated
+     */
+    updateTask(id: string, updates: TaskUpdate): boolean;
+    /**
+     * Remove a task from the queue (only works for queued tasks)
+     * @param id Task ID
+     * @returns true if task was found and removed
+     */
+    removeTask(id: string): boolean;
+    /**
+     * Cancel a task (works for queued or running tasks)
+     * @param id Task ID
+     * @returns true if task was found and cancelled
+     */
+    cancelTask(id: string): boolean;
+    /**
+     * Mark a task as started (moves from queue to running)
+     * @param id Task ID
+     * @returns The task if found and started
+     */
+    markStarted(id: string): QueuedTask | undefined;
+    /**
+     * Mark a task as completed (moves from running to history)
+     * @param id Task ID
+     * @param result The result of execution
+     * @returns The task if found and completed
+     */
+    markCompleted(id: string, result?: unknown): QueuedTask | undefined;
+    /**
+     * Mark a task as failed (moves from running to history)
+     * @param id Task ID
+     * @param error The error that occurred
+     * @returns The task if found and marked as failed
+     */
+    markFailed(id: string, error: Error | string): QueuedTask | undefined;
+    /**
+     * Increment retry count and optionally re-queue the task
+     * @param id Task ID
+     * @param requeue Whether to re-queue the task
+     * @returns The task if found
+     */
+    markRetry(id: string, requeue?: boolean): QueuedTask | undefined;
+    /**
+     * Move a completed/failed task from history back to the queue.
+     * Used when a follow-up is enqueued for a completed chat task so the
+     * parent task appears under "Queued" while the follow-up waits.
+     *
+     * @param id Task ID to requeue
+     * @returns true if the task was found in history and moved to the queue
+     */
+    requeueFromHistory(id: string): boolean;
+    /**
+     * Move a queued task back to history as completed.
+     * Reverses requeueFromHistory— used when a follow-up is cancelled
+     * so the parent task returns to the completed section.
+     *
+     * @param id Task ID to return to history
+     * @returns true if the task was found in the queue and moved to history
+     */
+    returnToHistory(id: string): boolean;
+    /**
+     * Re-activate a task from history (or queue) back to running state.
+     * Used to reuse a completed task (e.g. a chat session receiving follow-ups)
+     * instead of creating a separate task for each interaction.
+     *
+     * @param id Task ID to re-activate
+     * @returns true if the task was found in history/queue and moved to running
+     */
+    reActivate(id: string): boolean;
+    /**
+     * Freeze a queued task so the executor skips it.
+     * The task remains in its queue position with status 'queued'.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and frozen
+     */
+    freezeTask(id: string): boolean;
+    /**
+     * Unfreeze a previously frozen task, making it eligible for execution again.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and unfrozen
+     */
+    unfreezeTask(id: string): boolean;
+    /**
+     * Admit a held autopilot task so it runs despite autopilot being paused.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and admitted
+     */
+    admitTask(id: string): boolean;
+    /**
+     * Unadmit a previously admitted task, reverting it to held state.
+     * @param id Task ID
+     * @returns true if the task was found in the queue and unadmitted
+     */
+    unadmitTask(id: string): boolean;
+    /**
+     * Insert a pause marker at the given position in the queue.
+     * When the executor reaches the marker, it pauses and discards it.
+     *
+     * @param afterIndex 0-based index of the item after which the marker is inserted.
+     *   Pass -1 to insert at the very beginning.
+     *   Values >= queue.length insert at the end.
+     * @returns The id of the newly created marker.
+     */
+    insertPauseMarker(afterIndex: number): string;
+    /**
+     * Remove a pause marker by id.
+     * @returns true if the marker was found and removed
+     */
+    removePauseMarker(markerId: string): boolean;
+    /**
+     * Move a task to the top of the queue (highest priority position)
+     * @param id Task ID
+     * @returns true if task was found and moved
+     */
+    moveToTop(id: string): boolean;
+    /**
+     * Move a task up one position in the queue
+     * @param id Task ID
+     * @returns true if task was found and moved
+     */
+    moveUp(id: string): boolean;
+    /**
+     * Move a task down one position in the queue
+     * @param id Task ID
+     * @returns true if task was found and moved
+     */
+    moveDown(id: string): boolean;
+    /**
+     * Move a task to an arbitrary position in the queue (0-based index).
+     * Does not mutate priority (unlike moveToTop).
+     * @param id Task ID
+     * @param targetIndex Desired 0-based index (clamped to valid range)
+     * @returns true if the task was found (even if already at target), false if not found
+     */
+    moveToPosition(id: string, targetIndex: number): boolean;
+    /**
+     * Get the position of a task in the queue (1-based)
+     * @param id Task ID
+     * @returns Position (1-based) or -1 if not found
+     */
+    getPosition(id: string): number;
+    /**
+     * Pause queue processing
+     * Running tasks continue, but no new tasks will be started
+     */
+    pause(): void;
+    /**
+     * Resume queue processing
+     */
+    resume(): void;
+    /**
+     * Check if queue is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Pause autopilot — prevents new tasks from being enqueued automatically.
+     * Running and already-queued tasks are unaffected.
+     */
+    pauseAutopilot(): void;
+    /**
+     * Resume autopilot — allows automatic enqueuing to proceed again.
+     * Clears any stale admitted flags on queued tasks.
+     */
+    resumeAutopilot(): void;
+    /**
+     * Check if autopilot is paused.
+     */
+    isAutopilotPaused(): boolean;
+    /**
+     * Pause queue processing for a specific repository.
+     * Tasks from this repo will remain in queue but won't be dequeued.
+     */
+    pauseRepo(repoId: string, reason?: PauseReason): void;
+    /**
+     * Resume queue processing for a specific repository.
+     */
+    resumeRepo(repoId: string): void;
+    /**
+     * Check if a specific repository is paused.
+     */
+    isRepoPaused(repoId: string): boolean;
+    /**
+     * Get all paused repository IDs.
+     */
+    getPausedRepos(): string[];
+    /**
+     * Get the pause reason for a specific repository (if any).
+     */
+    getPauseReason(repoId: string): PauseReason | undefined;
+    /**
+     * Enter drain mode: stop accepting new tasks.
+     * Existing queued and running tasks continue to completion.
+     */
+    enterDrainMode(): void;
+    /**
+     * Exit drain mode: re-enable normal task acceptance.
+     */
+    exitDrainMode(): void;
+    /**
+     * Check if the queue is in drain mode.
+     */
+    isDraining(): boolean;
+    /**
+     * Wait until the queue is idle (queued=0 and running=0).
+     * Resolves immediately if already idle.
+     */
+    waitUntilIdle(): Promise<void>;
+    /**
+     * Get counts of queued and running tasks.
+     */
+    getTaskCounts(): {
+        queued: number;
+        running: number;
+        total: number;
+    };
+    /**
+     * Clear all queued tasks and markers (does not affect running or history)
+     */
+    clear(): void;
+    /**
+     * Restore history entries (e.g. from persisted state on startup).
+     * Prepends tasks to history, respecting maxHistorySize.
+     */
+    restoreHistory(tasks: QueuedTask[]): void;
+    /**
+     * Clear history
+     */
+    clearHistory(): void;
+    /**
+     * Remove a single entry from history by task ID.
+     * @returns true if the entry was found and removed, false otherwise.
+     */
+    removeHistoryEntry(taskId: string): boolean;
+    /**
+     * Force-fail all running tasks (e.g., stale processes killed externally).
+     * Moves all running tasks to history with a failed status.
+     * @param error Error message to set on the failed tasks
+     * @returns The number of tasks force-failed
+     */
+    forceFailRunning(error?: string): number;
+    /**
+     * Force-fail a single running task by ID.
+     * @param id Task ID
+     * @param error Error message
+     * @returns true if task was found and force-failed
+     */
+    forceFailTask(id: string, error?: string): boolean;
+    /**
+     * Reset the queue manager (clears everything)
+     */
+    reset(): void;
+    /**
+     * Check if queue is idle and resolve pending waiters
+     */
+    private checkIdle;
+    /**
+     * Route a task to the correct insertion method based on exclusivity.
+     * Non-exclusive tasks jump before the first exclusive task so they are not
+     * blocked behind an exclusive-limiter backlog. Exclusive tasks use standard
+     * priority insertion.
+     */
+    private insertTask;
+    /**
+     * Insert a non-exclusive task right before the first exclusive task in the
+     * queue so it is not blocked behind the exclusive-limiter backlog.
+     * Falls back to insertByPriority if there are no exclusive tasks ahead.
+     * Pause markers are treated as transparent (not exclusive).
+     */
+    private insertBeforeFirstExclusive;
+    /**
+     * Insert a task into the queue maintaining priority order.
+     * Uses a linear scan because pause markers can interrupt the sorted order.
+     * Markers are transparent in priority comparison — the task is inserted before
+     * the first task with strictly lower priority, which may place it before or
+     * after existing markers.
+     */
+    private insertByPriority;
+    /**
+     * Add a task to history, respecting max history size
+     */
+    private addToHistory;
+    /**
+     * Emit a queue change event
+     */
+    private emitChange;
+}
+/**
+ * Create a new TaskQueueManager instance
+ */
+export declare function createTaskQueueManager(options?: TaskQueueManagerOptions): TaskQueueManager;
+//# sourceMappingURL=task-queue-manager.d.ts.map

package/node_modules/@plusplusoneplusplus/forge/dist/queue/task-queue-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-queue-manager.d.ts","sourceRoot":"","sources":["../../src/queue/task-queue-manager.ts"],"names":[],"mappings":"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"}