byterover-cli 1.0.2 → 1.0.4

package/dist/infra/cipher/consumer/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * Consumer Module - Public API for queue processing and UI monitoring
- *
- * Architecture (legacy):
- * - ConsumerService: Singleton background worker (start once in main)
- * - QueuePollingService: UI subscribes here for real-time updates
- * - Both communicate via AgentStorage (SQLite DB)
- *
- * Usage:
- * ```typescript
- * // Main process - start consumer singleton
- * import { getConsumerService } from 'byterover-cli/dist/infra/cipher/consumer'
- * const consumer = getConsumerService({ concurrency: 5 })
- * await consumer.start()
- *
- * // UI components - subscribe to polling service
- * import { getQueuePollingService } from 'byterover-cli/dist/infra/cipher/consumer'
- * const poller = getQueuePollingService({ pollInterval: 500 })
- * poller.on('snapshot', (snapshot) => renderUI(snapshot))
- * poller.on('execution:completed', (exec) => showNotification(exec))
- * await poller.start()
- *
- * // Cleanup
- * consumer.dispose()
- * poller.stop()
- * ```
- */
-export { isConsumerRunning, isConsumerRunningSync } from './consumer-lock.js';
-export { ConsumerService, disposeConsumerService, getConsumerService } from './consumer-service.js';
-export type { ConsumerServiceOptions } from './consumer-service.js';
-export { createExecutionConsumer, ExecutionConsumer, getConsumer, stopConsumer, tryStartConsumer, } from './execution-consumer.js';
-export { getQueuePollingService, QueuePollingService, stopQueuePollingService } from './queue-polling-service.js';
-export type { ExecutionWithToolCalls, QueueSnapshot, QueueStats } from './queue-polling-service.js';

package/dist/infra/cipher/consumer/index.js

@@ -1,34 +0,0 @@
-// TODO(v0.5.0): Remove this entire module. Replaced by CoreProcess + TaskProcessor + Transport events.
-/**
- * Consumer Module - Public API for queue processing and UI monitoring
- *
- * Architecture (legacy):
- * - ConsumerService: Singleton background worker (start once in main)
- * - QueuePollingService: UI subscribes here for real-time updates
- * - Both communicate via AgentStorage (SQLite DB)
- *
- * Usage:
- * ```typescript
- * // Main process - start consumer singleton
- * import { getConsumerService } from 'byterover-cli/dist/infra/cipher/consumer'
- * const consumer = getConsumerService({ concurrency: 5 })
- * await consumer.start()
- *
- * // UI components - subscribe to polling service
- * import { getQueuePollingService } from 'byterover-cli/dist/infra/cipher/consumer'
- * const poller = getQueuePollingService({ pollInterval: 500 })
- * poller.on('snapshot', (snapshot) => renderUI(snapshot))
- * poller.on('execution:completed', (exec) => showNotification(exec))
- * await poller.start()
- *
- * // Cleanup
- * consumer.dispose()
- * poller.stop()
- * ```
- */
-// ==================== LOW-LEVEL API (for advanced usage) ====================
-export { isConsumerRunning, isConsumerRunningSync } from './consumer-lock.js';
-// ==================== HIGH-LEVEL API (for UI/REPL) ====================
-export { ConsumerService, disposeConsumerService, getConsumerService } from './consumer-service.js';
-export { createExecutionConsumer, ExecutionConsumer, getConsumer, stopConsumer, tryStartConsumer, } from './execution-consumer.js';
-export { getQueuePollingService, QueuePollingService, stopQueuePollingService } from './queue-polling-service.js';

package/dist/infra/cipher/consumer/queue-polling-service.d.ts

@@ -1,120 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { Execution, ToolCall } from '../storage/agent-storage.js';
-export interface QueueStats {
-    completed: number;
-    failed: number;
-    queued: number;
-    running: number;
-    total: number;
-}
-export interface ExecutionWithToolCalls {
-    execution: Execution;
-    toolCalls: ToolCall[];
-}
-export interface QueueSnapshot {
-    /** All executions for the current session (with tool calls) - ordered by created_at ASC */
-    sessionExecutions: ExecutionWithToolCalls[];
-    stats: QueueStats;
-    timestamp: number;
-}
-export type QueueEventType = 'error' | 'execution:completed' | 'execution:failed' | 'execution:started' | 'reconnected' | 'snapshot' | 'stats:updated' | 'stopped';
-export interface QueueEvents {
-    error: (error: Error) => void;
-    'execution:completed': (execution: Execution) => void;
-    'execution:failed': (execution: Execution) => void;
-    'execution:started': (execution: Execution) => void;
-    reconnected: () => void;
-    snapshot: (snapshot: QueueSnapshot) => void;
-    'stats:updated': (stats: QueueStats) => void;
-    stopped: () => void;
-}
-/**
- * QueuePollingService - Singleton service that polls agent.db and emits events
- *
- * Architecture:
- * - Polls database at configurable interval (default 500ms)
- * - Compares snapshots to detect changes
- * - Emits granular events for UI updates
- * - Singleton pattern prevents memory leaks from multiple instances
- *
- * Events:
- * - 'snapshot': Full queue snapshot (for initial render)
- * - 'stats:updated': Queue statistics changed
- * - 'execution:started': New execution started
- * - 'execution:completed': Execution completed successfully
- * - 'execution:failed': Execution failed
- * - 'error': Polling error occurred
- * - 'stopped': Service stopped
- */
-export declare class QueuePollingService extends EventEmitter {
-    private consumerId?;
-    private initialized;
-    private lastSnapshot;
-    private pollInterval;
-    private pollTimer;
-    private running;
-    private seenExecutionIds;
-    constructor(options?: {
-        consumerId?: string;
-        pollInterval?: number;
-    });
-    /**
-     * Get current snapshot without polling
-     */
-    getCurrentSnapshot(): null | QueueSnapshot;
-    /**
-     * Check if service is running
-     */
-    isRunning(): boolean;
-    /**
-     * Set consumer ID for session-based execution history
-     * Takes effect on next poll cycle
-     */
-    setConsumerId(consumerId: string | undefined): void;
-    /**
-     * Set poll interval (takes effect on next poll)
-     */
-    setPollInterval(ms: number): void;
-    /**
-     * Start polling
-     */
-    start(): Promise<void>;
-    /**
-     * Stop polling
-     */
-    stop(): void;
-    /**
-     * Build current snapshot from database
-     */
-    private buildSnapshot;
-    /**
-     * Detect changes and emit appropriate events
-     */
-    private detectChangesAndEmit;
-    /**
-     * Single poll iteration
-     */
-    private poll;
-    /**
-     * Schedule next poll
-     */
-    private schedulePoll;
-    /**
-     * Compare two stats objects for equality
-     */
-    private statsEqual;
-}
-/**
- * Get singleton QueuePollingService instance
- * @param options - Configuration options
- * @param options.consumerId - Optional consumer identifier
- * @param options.pollInterval - Optional poll interval in milliseconds
- */
-export declare function getQueuePollingService(options?: {
-    consumerId?: string;
-    pollInterval?: number;
-}): QueuePollingService;
-/**
- * Stop and clear singleton instance
- */
-export declare function stopQueuePollingService(): void;

package/dist/infra/cipher/consumer/queue-polling-service.js

@@ -1,249 +0,0 @@
-// TODO(v0.5.0): Remove this file. QueuePollingService is replaced by Transport events.
-import { EventEmitter } from 'node:events';
-import { closeAgentStorage, getAgentStorage, getAgentStorageSync } from '../storage/agent-storage.js';
-// ==================== SERVICE ====================
-/**
- * QueuePollingService - Singleton service that polls agent.db and emits events
- *
- * Architecture:
- * - Polls database at configurable interval (default 500ms)
- * - Compares snapshots to detect changes
- * - Emits granular events for UI updates
- * - Singleton pattern prevents memory leaks from multiple instances
- *
- * Events:
- * - 'snapshot': Full queue snapshot (for initial render)
- * - 'stats:updated': Queue statistics changed
- * - 'execution:started': New execution started
- * - 'execution:completed': Execution completed successfully
- * - 'execution:failed': Execution failed
- * - 'error': Polling error occurred
- * - 'stopped': Service stopped
- */
-// eslint-disable-next-line unicorn/prefer-event-target -- EventEmitter better for Node.js typed events
-export class QueuePollingService extends EventEmitter {
-    consumerId;
-    initialized = false;
-    lastSnapshot = null;
-    pollInterval;
-    pollTimer = null;
-    running = false;
-    seenExecutionIds = new Set();
-    constructor(options) {
-        super();
-        this.consumerId = options?.consumerId;
-        this.pollInterval = options?.pollInterval ?? 500;
-    }
-    /**
-     * Get current snapshot without polling
-     */
-    getCurrentSnapshot() {
-        return this.lastSnapshot;
-    }
-    /**
-     * Check if service is running
-     */
-    isRunning() {
-        return this.running;
-    }
-    /**
-     * Set consumer ID for session-based execution history
-     * Takes effect on next poll cycle
-     */
-    setConsumerId(consumerId) {
-        this.consumerId = consumerId;
-        // Clear last snapshot to force fresh data with new consumer
-        this.lastSnapshot = null;
-        this.seenExecutionIds.clear();
-    }
-    /**
-     * Set poll interval (takes effect on next poll)
-     */
-    setPollInterval(ms) {
-        this.pollInterval = ms;
-    }
-    /**
-     * Start polling
-     */
-    async start() {
-        if (this.running)
-            return;
-        try {
-            // Initialize storage (auto-detects .brv/blobs from cwd)
-            await getAgentStorage();
-            this.initialized = true;
-            this.running = true;
-            // Initial poll
-            await this.poll();
-            // Start poll loop
-            this.schedulePoll();
-        }
-        catch (error) {
-            this.emit('error', error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Stop polling
-     */
-    stop() {
-        this.running = false;
-        if (this.pollTimer) {
-            clearTimeout(this.pollTimer);
-            this.pollTimer = null;
-        }
-        if (this.initialized) {
-            closeAgentStorage();
-            this.initialized = false;
-        }
-        this.emit('stopped');
-    }
-    // ==================== PRIVATE ====================
-    /**
-     * Build current snapshot from database
-     */
-    buildSnapshot() {
-        const storage = getAgentStorageSync();
-        // Get session executions with tool calls (if consumerId is set)
-        let sessionExecutions = [];
-        if (this.consumerId) {
-            const sessionExecs = storage.getSessionExecutions(this.consumerId);
-            sessionExecutions = sessionExecs.map((exec) => ({
-                execution: exec,
-                toolCalls: storage.getToolCalls(exec.id),
-            }));
-        }
-        // Get stats directly from DB (accurate counts)
-        const stats = storage.getStats();
-        return {
-            sessionExecutions,
-            stats,
-            timestamp: Date.now(),
-        };
-    }
-    /**
-     * Detect changes and emit appropriate events
-     */
-    detectChangesAndEmit(oldSnapshot, newSnapshot) {
-        // Always emit snapshot for subscribers that want full state
-        this.emit('snapshot', newSnapshot);
-        // Detect stats changes
-        if (!oldSnapshot || !this.statsEqual(oldSnapshot.stats, newSnapshot.stats)) {
-            this.emit('stats:updated', newSnapshot.stats);
-        }
-        // Detect execution state changes
-        const executions = newSnapshot.sessionExecutions.map((e) => e.execution);
-        for (const exec of executions) {
-            const wasSeenBefore = this.seenExecutionIds.has(exec.id);
-            if (wasSeenBefore) {
-                // Check if status changed
-                const oldExecs = oldSnapshot?.sessionExecutions.map((e) => e.execution) ?? [];
-                const oldExec = oldExecs.find((e) => e.id === exec.id);
-                if (oldExec && oldExec.status !== exec.status) {
-                    if (exec.status === 'completed') {
-                        this.emit('execution:completed', exec);
-                    }
-                    else if (exec.status === 'failed') {
-                        this.emit('execution:failed', exec);
-                    }
-                }
-            }
-            else {
-                this.seenExecutionIds.add(exec.id);
-                if (exec.status === 'running') {
-                    this.emit('execution:started', exec);
-                }
-            }
-        }
-        // Limit seen IDs to prevent memory growth
-        if (this.seenExecutionIds.size > 1000) {
-            const idsToKeep = new Set(executions.map((e) => e.id));
-            this.seenExecutionIds = idsToKeep;
-        }
-    }
-    /**
-     * Single poll iteration
-     */
-    async poll() {
-        if (!this.running || !this.initialized)
-            return;
-        try {
-            // Check if DB file was replaced (e.g., by brv init in another terminal)
-            const storage = getAgentStorageSync();
-            if (storage.isDbFileChanged()) {
-                // DB file was replaced - reconnect
-                await storage.reconnect();
-                // Clear seen IDs since DB was reset
-                this.seenExecutionIds.clear();
-                this.lastSnapshot = null;
-                this.emit('reconnected');
-            }
-            const newSnapshot = this.buildSnapshot();
-            this.detectChangesAndEmit(this.lastSnapshot, newSnapshot);
-            this.lastSnapshot = newSnapshot;
-        }
-        catch (error) {
-            // If stop() was called during poll, silently exit - this is expected during shutdown
-            if (!this.running)
-                return;
-            // Try to recover from errors (connection lost, storage closed, etc.)
-            try {
-                // Use getAgentStorage() which auto-reinitializes if singleton was closed
-                const storage = await getAgentStorage();
-                await storage.reconnect();
-                this.seenExecutionIds.clear();
-                this.lastSnapshot = null;
-                this.emit('reconnected');
-            }
-            catch {
-                // Reconnect failed - only emit error if still running (not during intentional shutdown)
-                if (this.running) {
-                    this.emit('error', error instanceof Error ? error : new Error(String(error)));
-                }
-            }
-        }
-    }
-    /**
-     * Schedule next poll
-     */
-    schedulePoll() {
-        if (!this.running)
-            return;
-        this.pollTimer = setTimeout(async () => {
-            await this.poll();
-            this.schedulePoll();
-        }, this.pollInterval);
-    }
-    /**
-     * Compare two stats objects for equality
-     */
-    statsEqual(a, b) {
-        return (a.queued === b.queued &&
-            a.running === b.running &&
-            a.completed === b.completed &&
-            a.failed === b.failed &&
-            a.total === b.total);
-    }
-}
-// ==================== SINGLETON ====================
-let instance = null;
-/**
- * Get singleton QueuePollingService instance
- * @param options - Configuration options
- * @param options.consumerId - Optional consumer identifier
- * @param options.pollInterval - Optional poll interval in milliseconds
- */
-export function getQueuePollingService(options) {
-    if (!instance) {
-        instance = new QueuePollingService(options);
-    }
-    return instance;
-}
-/**
- * Stop and clear singleton instance
- */
-export function stopQueuePollingService() {
-    if (instance) {
-        instance.stop();
-        instance = null;
-    }
-}

package/dist/infra/cipher/storage/agent-storage.d.ts

@@ -1,246 +0,0 @@
-import type { Execution, ExecutionStatus, ExecutionType, ToolCall, ToolCallInfo, ToolCallStatus, ToolCallUpdateOptions } from '../../../core/domain/cipher/queue/types.js';
-import type { IAgentStorage } from '../../../core/interfaces/cipher/i-agent-storage.js';
-export type { ConsumerLock, Execution, ExecutionStatus, ExecutionType, ToolCall, ToolCallInfo, ToolCallStatus, ToolCallUpdateOptions, } from '../../../core/domain/cipher/queue/types.js';
-/**
- * AgentStorage - SQLite-based storage for execution queue and tool calls
- *
- * Features:
- * - Single database file at .brv/blobs/agent.db
- * - Job queue via executions.status = 'queued'
- * - Tool call tracking for UI polling
- * - Prepared statement caching (no memory leak)
- * - WAL mode for concurrent read/write
- * - Orphan cleanup on startup
- * - Old execution cleanup (max 100)
- */
-export declare class AgentStorage implements IAgentStorage {
-    initialized: boolean;
-    private db;
-    private dbFileInode;
-    private readonly dbPath;
-    private readonly inMemory;
-    private stmtAddToolCall;
-    private stmtCleanupOrphans;
-    private stmtCountCompletedFailed;
-    private stmtCreateExecution;
-    private stmtDeleteConsumerLock;
-    private stmtDeleteOldExecutions;
-    private stmtDequeueBatchSelect;
-    private stmtDequeueSelect;
-    private stmtFailQuery;
-    private stmtGetExecution;
-    private stmtGetExecutionsSince;
-    private stmtGetQueuedExecutions;
-    private stmtGetRecentExecutions;
-    private stmtGetRunningExecutions;
-    private stmtGetToolCalls;
-    private stmtOrphanFromConsumer;
-    private stmtOrphanMissingConsumer;
-    private stmtOrphanNullConsumer;
-    private stmtUpdateStatus;
-    private stmtUpdateToolCall;
-    private readonly storageDir;
-    constructor(config?: {
-        inMemory?: boolean;
-        storageDir?: string;
-    });
-    /**
-     * Acquire consumer lock (register this consumer)
-     * Only ONE consumer can run at a time - checks for any active consumer first
-     * @returns true if lock acquired, false if another consumer is already running
-     */
-    acquireConsumerLock(consumerId: string): boolean;
-    /**
-     * Add a tool call record
-     * @returns tool call id
-     */
-    addToolCall(executionId: string, info: ToolCallInfo): string;
-    /**
-     * Cleanup old executions, keep only maxKeep most recent completed/failed
-     */
-    cleanupOldExecutions(maxKeep?: number): number;
-    /**
-     * Cleanup orphaned executions (status='running') from previous session crash
-     * Should be called on startup
-     */
-    cleanupOrphanedExecutions(): number;
-    /**
-     * Cleanup stale consumers and orphan their executions
-     * A consumer is stale if its heartbeat is older than timeoutMs
-     * @param timeoutMs - heartbeat timeout (default 30 seconds)
-     * @returns number of orphaned executions
-     */
-    cleanupStaleConsumers(timeoutMs?: number): number;
-    /**
-     * Close database connection
-     */
-    close(): void;
-    /**
-     * Create a new execution
-     * @param type - 'curate' or 'query'
-     * @param input - content (curate) or query string (query)
-     * @returns execution id
-     */
-    createExecution(type: ExecutionType, input: string): string;
-    /**
-     * Dequeue multiple executions at once (atomic batch SELECT + UPDATE)
-     * This is more efficient than calling dequeueExecution() multiple times
-     * and ensures all queued items are seen in a single transaction snapshot
-     * @param limit - max number of executions to dequeue
-     * @param consumerId - ID of the consumer claiming these executions
-     * @returns array of executions (may be empty if queue is empty)
-     */
-    dequeueBatch(limit: number, consumerId?: string): Execution[];
-    /**
-     * Dequeue next queued execution (atomic SELECT + UPDATE)
-     * @param consumerId - ID of the consumer claiming this execution
-     * @returns execution or null if queue is empty
-     */
-    dequeueExecution(consumerId?: string): Execution | null;
-    /**
-     * Get execution by id
-     */
-    getExecution(id: string): Execution | null;
-    /**
-     * Get executions updated since timestamp (for incremental polling)
-     */
-    getExecutionsSince(timestamp: number): Execution[];
-    /**
-     * Get execution with all its tool calls (for UI display)
-     */
-    getExecutionWithToolCalls(id: string): null | {
-        execution: Execution;
-        toolCalls: ToolCall[];
-    };
-    /**
-     * Get all queued executions
-     */
-    getQueuedExecutions(): Execution[];
-    /**
-     * Get recent executions (for UI display)
-     */
-    getRecentExecutions(limit?: number): Execution[];
-    /**
-     * Get all running executions
-     */
-    getRunningExecutions(): Execution[];
-    /**
-     * Get all executions belonging to a specific consumer session.
-     * Returns executions ordered by created_at ASC (oldest first, newest last).
-     * Includes:
-     * - Curate executions with matching consumer_id
-     * - Query executions created after consumer started (no consumer_id)
-     */
-    getSessionExecutions(consumerId: string): Execution[];
-    /**
-     * Get queue statistics (queries DB directly for accurate counts)
-     */
-    getStats(): {
-        completed: number;
-        failed: number;
-        queued: number;
-        running: number;
-        total: number;
-    };
-    /**
-     * Get all tool calls for an execution
-     */
-    getToolCalls(executionId: string): ToolCall[];
-    /**
-     * Check if any consumer is currently active (has recent heartbeat)
-     * @param timeoutMs - heartbeat timeout (default 30 seconds)
-     */
-    hasActiveConsumer(timeoutMs?: number): boolean;
-    /**
-     * Check if a specific consumer lock exists in the database
-     * Used by Consumer to verify its lock is still valid after DB reconnection
-     */
-    hasConsumerLock(consumerId: string): boolean;
-    /**
-     * Initialize storage - create tables, enable WAL
-     * @param options - Initialization options
-     * @param options.cleanupOrphans - If true, cleanup orphaned executions (only Consumer should set this)
-     */
-    initialize(options?: {
-        cleanupOrphans?: boolean;
-    }): Promise<void>;
-    /**
-     * Check if the DB file has been replaced (different inode)
-     * Returns true if DB needs reconnection
-     */
-    isDbFileChanged(): boolean;
-    /**
-     * Reconnect to the database (close and reinitialize)
-     * Use when DB file has been replaced by another process (e.g., brv init)
-     */
-    reconnect(): Promise<void>;
-    /**
-     * Release consumer lock (unregister this consumer)
-     */
-    releaseConsumerLock(consumerId: string): void;
-    /**
-     * Update consumer heartbeat
-     */
-    updateConsumerHeartbeat(consumerId: string): void;
-    /**
-     * Update execution status
-     */
-    updateExecutionStatus(id: string, status: ExecutionStatus, result?: string, error?: string): void;
-    /**
-     * Update tool call status and result
-     */
-    updateToolCall(id: string, status: ToolCallStatus, options?: ToolCallUpdateOptions): void;
-    /**
-     * Ensure storage has been initialized
-     */
-    private ensureInitialized;
-    /**
-     * Get database instance with type safety (throws if not initialized)
-     * Use this instead of this.getDb() for proper type narrowing
-     */
-    private getDb;
-    /**
-     * Convert database row to Execution object
-     */
-    private rowToExecution;
-    /**
-     * Convert database row to ToolCall object
-     */
-    private rowToToolCall;
-}
-/**
- * Get the singleton AgentStorage instance (auto-initializes if needed)
- *
- * This is the PRIMARY API - just call this and it handles everything.
- * First call will initialize with provided config, subsequent calls return cached instance.
- *
- * @param config - Configuration options
- * @param config.cleanupOrphans - Cleanup orphaned executions (only Consumer should set this)
- * @param config.inMemory - Use in-memory database (for testing)
- * @param config.storageDir - Directory for agent.db (default: .brv/blobs)
- */
-export declare function getAgentStorage(config?: {
-    cleanupOrphans?: boolean;
-    inMemory?: boolean;
-    storageDir?: string;
-}): Promise<AgentStorage>;
-/**
- * Get the singleton AgentStorage instance (sync version)
- * THROWS if not initialized - use getAgentStorage() instead for auto-init
- *
- * Use this only when you KNOW storage is already initialized (e.g., in Consumer after start)
- */
-export declare function getAgentStorageSync(): AgentStorage;
-/**
- * Initialize the singleton AgentStorage instance
- * @deprecated Use getAgentStorage() directly - it auto-initializes
- */
-export declare function initializeAgentStorage(config?: {
-    cleanupOrphans?: boolean;
-    inMemory?: boolean;
-    storageDir?: string;
-}): Promise<AgentStorage>;
-/**
- * Close and clear the singleton AgentStorage instance
- */
-export declare function closeAgentStorage(): void;