byterover-cli 0.3.5 → 0.4.0

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

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,248 @@
+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/http/internal-llm-http-service.d.ts

@@ -0,0 +1,94 @@
+import type { RequestOptions } from '@anthropic-ai/sdk/internal/request-options';
+import type { MessageCreateParamsNonStreaming } from '@anthropic-ai/sdk/resources/messages.js';
+import type { Content, GenerateContentConfig, GenerateContentResponse } from '@google/genai';
+/**
+ * ByteRover HTTP LLM provider configuration.
+ */
+export interface ByteRoverHttpConfig {
+    accessToken: string;
+    apiBaseUrl: string;
+    projectId?: string;
+    region?: string;
+    sessionKey: string;
+    spaceId: string;
+    teamId: string;
+    timeout?: number;
+}
+/**
+ * ByteRover HTTP LLM API client.
+ *
+ * Simple wrapper around ByteRover REST LLM service.
+ * Delegates prompt building and formatting to service layer.
+ *
+ * Responsibilities:
+ * - Call the remote REST API
+ * - Handle HTTP responses
+ * - Convert to GenerateContentResponse format
+ *
+ * Does NOT:
+ * - Build prompts or format inputs
+ * - Parse or manipulate response content
+ * - Handle tool call parsing from text
+ */
+export declare class ByteRoverLlmHttpService {
+    private readonly config;
+    /**
+     * Initialize a new ByteRover HTTP LLM service client.
+     *
+     * Sets up configuration with sensible defaults:
+     * - projectId defaults to 'byterover'
+     * - region defaults to 'us-east1' (can be overridden per request)
+     * - timeout defaults to 60 seconds
+     *
+     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
+     */
+    constructor(config: ByteRoverHttpConfig);
+    /**
+     * Call ByteRover REST LLM service to generate content.
+     *
+     * Simple forward to remote REST API - delegates all formatting to backend.
+     * Supports both Gemini and Claude formats - the correct format is determined
+     * automatically based on the model name.
+     *
+     * Parameter structure differs by provider:
+     * - Gemini: contents = Content[], config = GenerateContentConfig
+     * - Claude: contents = MessageCreateParamsNonStreaming (complete body), config = RequestOptions (HTTP options)
+     *
+     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
+     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
+     * @param model - Model to use (detects provider from model name)
+     * @param executionMetadata - Optional execution metadata (mode, executionContext)
+     * @returns Response in GenerateContentResponse format
+     */
+    generateContent(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): Promise<GenerateContentResponse>;
+    /**
+     * Call the ByteRover REST Generate endpoint.
+     *
+     * Handles authentication headers and error handling.
+     *
+     * @param request - The REST generate request with model, provider, region, and params
+     * @returns Promise resolving to the complete LLM response
+     * @throws Error if the request fails
+     */
+    private callHttpGenerate;
+    /**
+     * Detect LLM provider from model identifier.
+     *
+     * Determines which provider (Claude or Gemini) to use based on the model name.
+     * Defaults to Gemini if the model doesn't match Claude patterns.
+     *
+     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
+     * @returns Provider name: 'claude' or 'gemini'
+     */
+    private detectProviderFromModel;
+    /**
+     * Detect appropriate GCP region from model identifier.
+     *
+     * Routes Claude models to us-east5 and Gemini models to global.
+     * This ensures compatibility with the provider's available regions on Vertex AI.
+     *
+     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
+     * @returns GCP region identifier ('us-east5' or 'global')
+     */
+    private detectRegionFromModel;
+}

package/dist/infra/cipher/http/internal-llm-http-service.js

@@ -0,0 +1,118 @@
+import { AuthenticatedHttpClient } from '../../http/authenticated-http-client.js';
+/**
+ * ByteRover HTTP LLM API client.
+ *
+ * Simple wrapper around ByteRover REST LLM service.
+ * Delegates prompt building and formatting to service layer.
+ *
+ * Responsibilities:
+ * - Call the remote REST API
+ * - Handle HTTP responses
+ * - Convert to GenerateContentResponse format
+ *
+ * Does NOT:
+ * - Build prompts or format inputs
+ * - Parse or manipulate response content
+ * - Handle tool call parsing from text
+ */
+export class ByteRoverLlmHttpService {
+    config;
+    /**
+     * Initialize a new ByteRover HTTP LLM service client.
+     *
+     * Sets up configuration with sensible defaults:
+     * - projectId defaults to 'byterover'
+     * - region defaults to 'us-east1' (can be overridden per request)
+     * - timeout defaults to 60 seconds
+     *
+     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
+     */
+    constructor(config) {
+        this.config = {
+            accessToken: config.accessToken,
+            apiBaseUrl: config.apiBaseUrl,
+            projectId: config.projectId ?? 'byterover',
+            region: config.region ?? 'us-east1',
+            sessionKey: config.sessionKey,
+            spaceId: config.spaceId,
+            teamId: config.teamId,
+            timeout: config.timeout ?? 60_000,
+        };
+    }
+    /**
+     * Call ByteRover REST LLM service to generate content.
+     *
+     * Simple forward to remote REST API - delegates all formatting to backend.
+     * Supports both Gemini and Claude formats - the correct format is determined
+     * automatically based on the model name.
+     *
+     * Parameter structure differs by provider:
+     * - Gemini: contents = Content[], config = GenerateContentConfig
+     * - Claude: contents = MessageCreateParamsNonStreaming (complete body), config = RequestOptions (HTTP options)
+     *
+     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
+     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
+     * @param model - Model to use (detects provider from model name)
+     * @param executionMetadata - Optional execution metadata (mode, executionContext)
+     * @returns Response in GenerateContentResponse format
+     */
+    async generateContent(contents, config, model, executionMetadata) {
+        const request = {
+            executionMetadata: JSON.stringify(executionMetadata ?? {}),
+            params: {
+                config: JSON.stringify(config),
+                contents: JSON.stringify(contents),
+                model,
+            },
+            project_id: this.config.projectId,
+            provider: this.detectProviderFromModel(model),
+            region: this.detectRegionFromModel(model),
+            spaceId: this.config.spaceId,
+            teamId: this.config.teamId,
+        };
+        return this.callHttpGenerate(request);
+    }
+    /**
+     * Call the ByteRover REST Generate endpoint.
+     *
+     * Handles authentication headers and error handling.
+     *
+     * @param request - The REST generate request with model, provider, region, and params
+     * @returns Promise resolving to the complete LLM response
+     * @throws Error if the request fails
+     */
+    async callHttpGenerate(request) {
+        const url = `${this.config.apiBaseUrl}/api/llm/generate`;
+        const httpClient = new AuthenticatedHttpClient(this.config.accessToken, this.config.sessionKey);
+        const response = await httpClient.post(url, request, {
+            timeout: this.config.timeout,
+        });
+        // Parse the JSON string response
+        const content = JSON.parse(response.data);
+        return content;
+    }
+    /**
+     * Detect LLM provider from model identifier.
+     *
+     * Determines which provider (Claude or Gemini) to use based on the model name.
+     * Defaults to Gemini if the model doesn't match Claude patterns.
+     *
+     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
+     * @returns Provider name: 'claude' or 'gemini'
+     */
+    detectProviderFromModel(model) {
+        return model.toLowerCase().startsWith('claude') ? 'claude' : 'gemini';
+    }
+    /**
+     * Detect appropriate GCP region from model identifier.
+     *
+     * Routes Claude models to us-east5 and Gemini models to global.
+     * This ensures compatibility with the provider's available regions on Vertex AI.
+     *
+     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
+     * @returns GCP region identifier ('us-east5' or 'global')
+     */
+    detectRegionFromModel(model) {
+        return model.toLowerCase().startsWith('claude') ? 'us-east5' : 'global';
+    }
+}

package/dist/infra/cipher/llm/context/compaction/compaction-service.d.ts

@@ -0,0 +1,106 @@
+import type { CompactionResult } from '../../../../../core/domain/cipher/storage/message-storage-types.js';
+import type { ITokenizer } from '../../../../../core/interfaces/cipher/i-tokenizer.js';
+import type { MessageStorageService } from '../../../storage/message-storage-service.js';
+/**
+ * Configuration for compaction behavior.
+ */
+export interface CompactionConfig {
+    /**
+     * Percentage of context tokens that triggers compaction (0.0 - 1.0).
+     * Default: 0.85 (85%)
+     */
+    overflowThreshold?: number;
+    /**
+     * Number of tokens to keep in tool outputs after pruning.
+     * Default: 40000
+     */
+    pruneKeepTokens?: number;
+    /**
+     * System prompt for generating compaction summaries.
+     */
+    summaryPrompt?: string;
+}
+/**
+ * Result of checking for context overflow.
+ */
+export interface OverflowCheckResult {
+    /** Current token count */
+    currentTokens: number;
+    /** Whether overflow threshold is exceeded */
+    isOverflow: boolean;
+    /** Maximum allowed tokens */
+    maxTokens: number;
+    /** Recommended action */
+    recommendation: 'compact' | 'none' | 'prune';
+}
+/**
+ * Input for compaction operations.
+ */
+export interface CompactionInput {
+    /** Maximum context tokens allowed */
+    contextLimit: number;
+    /** Current token count (including all messages) */
+    currentTokens: number;
+    /** Session ID to compact */
+    sessionId: string;
+}
+/**
+ * Service for managing context compaction in granular history storage.
+ *
+ * Compaction reduces context size through two mechanisms:
+ * 1. Tool output pruning - marks old tool outputs as compacted
+ * 2. Compaction boundaries - summarizes old history and creates a boundary
+ *
+ * Based on OpenCode's compaction patterns:
+ * - isOverflow() checks if context exceeds threshold
+ * - prune() marks old tool outputs as compacted
+ * - insertCompactionBoundary() creates a summary boundary
+ */
+export declare class CompactionService {
+    private readonly messageStorage;
+    private readonly tokenizer;
+    private readonly config;
+    constructor(messageStorage: MessageStorageService, tokenizer: ITokenizer, config?: CompactionConfig);
+    /**
+     * Perform automatic compaction based on current context state.
+     * This is a convenience method that checks overflow and takes appropriate action.
+     *
+     * @returns CompactionResult if action was taken, undefined if no action needed
+     */
+    autoCompact(input: CompactionInput): Promise<CompactionResult | undefined>;
+    /**
+     * Check if context is overflowing and recommend action.
+     */
+    checkOverflow(currentTokens: number, contextLimit: number): OverflowCheckResult;
+    /**
+     * Create a compaction boundary with the given summary.
+     * The boundary acts as a marker - history loading stops here.
+     */
+    createCompactionBoundary(sessionId: string, summary: string): Promise<void>;
+    /**
+     * Estimate tokens for a text string.
+     * Uses the configured tokenizer.
+     */
+    estimateTokens(text: string): Promise<number>;
+    /**
+     * Get the current compaction configuration.
+     */
+    getConfig(): Readonly<Required<CompactionConfig>>;
+    /**
+     * Generate a summary prompt for the LLM to create a compaction summary.
+     * This returns the system prompt and user message to send to the LLM.
+     */
+    getSummaryPromptParts(): {
+        systemPrompt: string;
+        userMessage: string;
+    };
+    /**
+     * Prune old tool outputs to reduce context size.
+     * Keeps the most recent tool outputs up to the configured token limit.
+     */
+    pruneToolOutputs(sessionId: string): Promise<CompactionResult>;
+}
+/**
+ * Factory function to create CompactionService.
+ */
+export declare function createCompactionService(messageStorage: MessageStorageService, tokenizer: ITokenizer, config?: CompactionConfig): CompactionService;