byterover-cli 0.4.1 → 1.0.1

package/dist/infra/cipher/{agent-service-factory.js → agent/service-initializer.js}

@@ -1,47 +1,73 @@
-import { join } from 'node:path';
-import { createBlobStorage } from './blob/blob-storage-factory.js';
-import { AgentEventBus, SessionEventBus } from './events/event-emitter.js';
-import { FileSystemService } from './file-system/file-system-service.js';
-import { ByteRoverLlmHttpService } from './http/internal-llm-http-service.js';
-import { ByteRoverContentGenerator, LoggingContentGenerator, RetryableContentGenerator } from './llm/generators/index.js';
-import { ByteRoverLLMService } from './llm/internal-llm-service.js';
-import { OpenRouterLLMService } from './llm/openrouter-llm-service.js';
-import { DEFAULT_RETRY_POLICY } from './llm/retry/retry-policy.js';
-import { EventBasedLogger } from './logger/event-based-logger.js';
-import { MemoryManager } from './memory/memory-manager.js';
-import { ProcessService } from './process/process-service.js';
-import { BlobHistoryStorage } from './storage/blob-history-storage.js';
-import { DualFormatHistoryStorage } from './storage/dual-format-history-storage.js';
-import { GranularHistoryStorage } from './storage/granular-history-storage.js';
-import { MessageStorageService } from './storage/message-storage-service.js';
-import { SqliteKeyStorage } from './storage/sqlite-key-storage.js';
-import { SimplePromptFactory } from './system-prompt/simple-prompt-factory.js';
-import { CoreToolScheduler } from './tools/core-tool-scheduler.js';
-import { DEFAULT_POLICY_RULES } from './tools/default-policy-rules.js';
-import { PolicyEngine } from './tools/policy-engine.js';
-import { ToolManager } from './tools/tool-manager.js';
-import { ToolProvider } from './tools/tool-provider.js';
+/**
+ * Service Initializer: Centralized Wiring for Cipher Agent Services
+ *
+ * This module is responsible for initializing and wiring together all core agent services.
+ * It provides a single entry point for constructing the service graph.
+ *
+ * Following DextoAgent pattern:
+ * - Config file is source of truth (ValidatedAgentConfig)
+ * - Centralized function (not factory class) for service creation
+ * - Explicit dependency order with numbered steps
+ * - Event bus passed in as parameter (created in agent constructor)
+ */
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createBlobStorage } from '../blob/blob-storage-factory.js';
+import { SessionEventBus } from '../events/event-emitter.js';
+import { FileSystemService } from '../file-system/file-system-service.js';
+import { ByteRoverLlmHttpService } from '../http/internal-llm-http-service.js';
+import { CompactionService } from '../llm/context/compaction/compaction-service.js';
+import { ByteRoverContentGenerator, LoggingContentGenerator, RetryableContentGenerator } from '../llm/generators/index.js';
+import { ByteRoverLLMService } from '../llm/internal-llm-service.js';
+import { OpenRouterLLMService } from '../llm/openrouter-llm-service.js';
+import { DEFAULT_RETRY_POLICY } from '../llm/retry/retry-policy.js';
+import { GeminiTokenizer } from '../llm/tokenizers/gemini-tokenizer.js';
+import { EventBasedLogger } from '../logger/event-based-logger.js';
+import { MemoryManager } from '../memory/memory-manager.js';
+import { ProcessService } from '../process/process-service.js';
+import { BlobHistoryStorage } from '../storage/blob-history-storage.js';
+import { DualFormatHistoryStorage } from '../storage/dual-format-history-storage.js';
+import { GranularHistoryStorage } from '../storage/granular-history-storage.js';
+import { MessageStorageService } from '../storage/message-storage-service.js';
+import { SqliteKeyStorage } from '../storage/sqlite-key-storage.js';
+import { ContextTreeStructureContributor } from '../system-prompt/contributors/context-tree-structure-contributor.js';
+import { SystemPromptManager } from '../system-prompt/system-prompt-manager.js';
+import { CoreToolScheduler } from '../tools/core-tool-scheduler.js';
+import { DEFAULT_POLICY_RULES } from '../tools/default-policy-rules.js';
+import { PolicyEngine } from '../tools/policy-engine.js';
+import { ToolDescriptionLoader } from '../tools/tool-description-loader.js';
+import { ToolManager } from '../tools/tool-manager.js';
+import { ToolProvider } from '../tools/tool-provider.js';
 /**
  * Creates shared services for CipherAgent.
  * These services are singletons shared across all sessions.
  *
- * Following Dexto's pattern: shared services are created once at agent level,
- * while session-specific services (LLM, EventBus) are created per session.
+ * Initialization order follows DextoAgent pattern (explicit numbered steps):
+ * 1. Logger (uses provided event bus)
+ * 2. File system service (no dependencies)
+ * 3. Process service (no dependencies)
+ * 4. Blob storage (no dependencies)
+ * 5. Memory system (depends on BlobStorage, Logger)
+ * 6. System prompt manager (no dependencies)
+ * 7. Tool provider (depends on FileSystemService, ProcessService, MemoryManager)
+ * 8. Policy engine (no dependencies)
+ * 9. Tool scheduler (depends on ToolProvider, PolicyEngine)
+ * 10. Tool manager (depends on ToolProvider, ToolScheduler)
+ * 11. History storage (depends on BlobStorage)
+ * 12. Return all services
  *
- * @param llmConfig - LLM configuration
+ * @param config - Validated agent configuration (Zod-validated)
+ * @param agentEventBus - Pre-created event bus from agent constructor (DextoAgent pattern)
  * @returns Initialized shared services
  */
-export async function createCipherAgentServices(llmConfig) {
-    // 1. Agent event bus (global)
-    const agentEventBus = new AgentEventBus();
-    // 2. Logger (depends on event bus)
+export async function createCipherAgentServices(config, agentEventBus) {
+    // 1. Logger (uses provided event bus - DextoAgent pattern)
     const logger = new EventBasedLogger(agentEventBus, 'CipherAgent');
-    // 3. File system service (no dependencies)
-    const fileSystemService = new FileSystemService(llmConfig.fileSystemConfig);
+    // 2. File system service (no dependencies)
+    const fileSystemService = new FileSystemService(config.fileSystem);
     await fileSystemService.initialize();
-    // 4. Process service (no dependencies)
-    // Use the same working directory as FileSystemService to ensure consistency
-    const workingDirectory = llmConfig.fileSystemConfig?.workingDirectory ?? process.cwd();
+    // 3. Process service (no dependencies)
+    const workingDirectory = config.fileSystem?.workingDirectory ?? process.cwd();
     const processService = new ProcessService({
         allowedCommands: [],
         blockedCommands: [],
@@ -53,27 +79,50 @@ export async function createCipherAgentServices(llmConfig) {
         workingDirectory,
     });
     await processService.initialize();
-    // 5. Blob storage (no dependencies)
-    // Always uses SQLite for performance and ACID transactions
-    const blobStorage = createBlobStorage(llmConfig.blobStorageConfig ?? {
+    // 4. Blob storage (no dependencies)
+    const blobStorage = createBlobStorage(config.blobStorage ?? {
         maxBlobSize: 100 * 1024 * 1024, // 100MB
         maxTotalSize: 1024 * 1024 * 1024, // 1GB
         storageDir: join(workingDirectory, '.brv', 'blobs'),
     });
     await blobStorage.initialize();
-    // 6. Memory system (depends on BlobStorage, Logger)
+    // 5. Memory system (depends on BlobStorage, Logger)
     const memoryLogger = logger.withSource('MemoryManager');
     const memoryManager = new MemoryManager(blobStorage, memoryLogger);
-    // 7. Simple prompt factory - SHARED across sessions
-    // Created early so it can be used by ToolProvider
-    const verbose = llmConfig.verbose ?? false;
-    const promptFactory = new SimplePromptFactory(undefined, verbose);
-    // 8. Tool system (depends on FileSystemService, ProcessService, MemoryManager, PromptFactory)
+    // 6. System prompt manager - SHARED across sessions
+    // Calculate path to prompts directory relative to this file's location
+    // This file is at dist/infra/cipher/agent/service-initializer.js
+    // Resources are at dist/resources/prompts/
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const promptsBasePath = join(currentDir, '../../../resources/prompts');
+    const systemPromptManager = new SystemPromptManager({
+        basePath: promptsBasePath,
+        validateConfig: true,
+    });
+    // Register default contributors
+    systemPromptManager.registerContributors([
+        { enabled: true, filepath: 'system-prompt.yml', id: 'base', priority: 0, type: 'file' },
+        { enabled: true, id: 'env', priority: 10, type: 'environment' },
+        { enabled: true, id: 'memories', priority: 20, type: 'memory' },
+        { enabled: true, id: 'datetime', priority: 30, type: 'dateTime' },
+    ]);
+    // Register context tree structure contributor for query/curate commands
+    // This injects the .brv/context-tree structure into the system prompt,
+    // giving agents immediate awareness of available curated knowledge.
+    // Priority 15 ensures it appears after environment but before memories.
+    const contextTreeContributor = new ContextTreeStructureContributor('contextTree', 15, {
+        workingDirectory,
+    });
+    systemPromptManager.registerContributor(contextTreeContributor);
+    // 7. Tool provider (depends on FileSystemService, ProcessService, MemoryManager, SystemPromptManager)
+    const verbose = config.llm.verbose ?? false;
+    const descriptionLoader = new ToolDescriptionLoader();
     const toolProvider = new ToolProvider({
         fileSystemService,
+        getToolProvider: () => toolProvider,
         memoryManager,
         processService,
-    }, promptFactory);
+    }, systemPromptManager, descriptionLoader);
     await toolProvider.initialize();
     // 8. Policy engine with default rules for autonomous execution
     const policyEngine = new PolicyEngine({ defaultDecision: 'ALLOW' });
@@ -86,42 +135,54 @@ export async function createCipherAgentServices(llmConfig) {
     const toolManager = new ToolManager(toolProvider, toolScheduler);
     await toolManager.initialize();
     // 11. History storage (depends on BlobStorage) - SHARED across sessions
-    // Use DualFormatHistoryStorage when granular storage is enabled
     let historyStorage;
-    if (llmConfig.useGranularStorage) {
+    let compactionService;
+    let messageStorageService;
+    if (config.useGranularStorage) {
         // Create granular storage infrastructure
         const keyStorage = new SqliteKeyStorage({
             storageDir: join(workingDirectory, '.brv'),
         });
         await keyStorage.initialize();
         const messageStorage = new MessageStorageService(keyStorage);
+        messageStorageService = messageStorage;
         const granularStorage = new GranularHistoryStorage(messageStorage);
         const blobHistoryStorage = new BlobHistoryStorage(blobStorage);
         // DualFormatHistoryStorage routes between formats:
         // - New sessions → GranularHistoryStorage
         // - Existing sessions → BlobHistoryStorage (no migration)
         historyStorage = new DualFormatHistoryStorage(blobHistoryStorage, granularStorage);
+        // Create CompactionService for context overflow management
+        const tokenizer = new GeminiTokenizer(config.model ?? 'gemini-2.5-pro');
+        compactionService = new CompactionService(messageStorage, tokenizer, {
+            overflowThreshold: 0.85, // 85% triggers compaction check
+            protectedTurns: 2, // Protect first 2 user turns from pruning
+            pruneKeepTokens: 40_000, // Keep 40k tokens in tool outputs
+            pruneMinimumTokens: 20_000, // Only prune if 20k+ tokens can be saved
+        });
         logger.info('Granular history storage enabled for new sessions');
     }
     else {
         // Default: use blob storage for all sessions
         historyStorage = new BlobHistoryStorage(blobStorage);
     }
-    // Log successful initialization
+    // 12. Log successful initialization
     logger.info('CipherAgent services initialized successfully', {
-        model: llmConfig.model,
-        verbose: llmConfig.verbose,
+        model: config.model,
+        verbose: config.llm.verbose,
         workingDirectory,
     });
     return {
         agentEventBus,
         blobStorage,
+        compactionService,
         fileSystemService,
         historyStorage,
         memoryManager,
+        messageStorageService,
         policyEngine,
         processService,
-        promptFactory,
+        systemPromptManager,
         toolManager,
         toolProvider,
         toolScheduler,
@@ -129,10 +190,6 @@ export async function createCipherAgentServices(llmConfig) {
 }
 /**
  * Creates session-specific services for a ChatSession.
- *
- * Following Dexto's pattern: each session gets its own LLM service and event bus
- * for conversation isolation, while using shared services for tools/prompts.
- *
  * Generator composition order (innermost to outermost):
  * 1. Base generator (ByteRoverContentGenerator or OpenRouterContentGenerator)
  * 2. RetryableContentGenerator - handles transient errors with backoff
@@ -142,14 +199,6 @@ export async function createCipherAgentServices(llmConfig) {
  * @param sharedServices - Shared services from agent
  * @param httpConfig - HTTP configuration
  * @param llmConfig - LLM service configuration
- * @param llmConfig.openRouterApiKey - Optional OpenRouter API key for OpenRouter service
- * @param llmConfig.httpReferer - Optional HTTP Referer for OpenRouter rankings
- * @param llmConfig.siteName - Optional site name for OpenRouter rankings
- * @param llmConfig.maxIterations - Maximum iterations for agentic loop
- * @param llmConfig.maxTokens - Maximum output tokens
- * @param llmConfig.model - LLM model identifier
- * @param llmConfig.temperature - Temperature for generation
- * @param llmConfig.verbose - Enable verbose debug output
  * @returns Initialized session services
  */
 export function createSessionServices(sessionId, sharedServices, httpConfig, llmConfig) {
@@ -158,11 +207,10 @@ export function createSessionServices(sessionId, sharedServices, httpConfig, llm
     // 2. Create session-scoped logger
     const sessionLogger = new EventBasedLogger(sharedServices.agentEventBus, 'LLMService', sessionId);
     // 3. Create LLM service based on configuration
-    // Priority: OpenRouter > ByteRover gRPC
+    // Priority: OpenRouter > ByteRover HTTP
     let llmService;
     if (llmConfig.openRouterApiKey) {
         // Use OpenRouter service when OpenRouter API key is provided
-        // OpenRouterLLMService still uses old pattern (to be migrated later)
         llmService = new OpenRouterLLMService(sessionId, {
             apiKey: llmConfig.openRouterApiKey,
             httpReferer: llmConfig.httpReferer,
@@ -176,12 +224,12 @@ export function createSessionServices(sessionId, sharedServices, httpConfig, llm
             logger: sessionLogger,
             memoryManager: sharedServices.memoryManager, // SHARED
             sessionEventBus,
-            systemPromptManager: sharedServices.promptFactory, // SHARED
+            systemPromptManager: sharedServices.systemPromptManager, // SHARED
             toolManager: sharedServices.toolManager, // SHARED
         });
     }
     else {
-        // Use HTTP backend service (default) with new generator pattern
+        // Use HTTP backend service (default) with generator pattern
         // Step 1: Create HTTP service
         const httpService = new ByteRoverLlmHttpService({
             accessToken: httpConfig.accessToken,
@@ -219,11 +267,12 @@ export function createSessionServices(sessionId, sharedServices, httpConfig, llm
             temperature: llmConfig.temperature ?? 0.7,
             verbose: llmConfig.verbose ?? false,
         }, {
+            compactionService: sharedServices.compactionService, // SHARED - for context overflow management
             historyStorage: sharedServices.historyStorage, // SHARED
             logger: sessionLogger,
             memoryManager: sharedServices.memoryManager, // SHARED
-            promptFactory: sharedServices.promptFactory, // SHARED
             sessionEventBus,
+            systemPromptManager: sharedServices.systemPromptManager, // SHARED
             toolManager: sharedServices.toolManager, // SHARED
         });
     }

package/dist/infra/cipher/agent/types.d.ts

@@ -0,0 +1,35 @@
+import type { AgentExecutionState } from '../../../core/interfaces/cipher/i-cipher-agent.js';
+import type { AgentEventBus } from '../events/event-emitter.js';
+/**
+ * Termination reason type for agent execution.
+ */
+export type TerminationReason = 'ABORTED' | 'ERROR' | 'GOAL' | 'MAX_TURNS' | 'PROTOCOL_VIOLATION' | 'TIMEOUT';
+/**
+ * Agent execution context with enhanced state tracking.
+ */
+export interface AgentExecutionContext {
+    currentIteration: number;
+    durationMs?: number;
+    endTime?: Date;
+    executionState: AgentExecutionState;
+    startTime?: Date;
+    terminationReason?: TerminationReason;
+    toolCallsExecuted: number;
+}
+/**
+ * Agent event subscriber interface.
+ * Objects implementing this can be registered for event subscription.
+ * Follows DextoAgent's AgentEventSubscriber pattern.
+ */
+export interface AgentEventSubscriber {
+    /**
+     * Subscribe to events on the agent event bus.
+     * Called when the agent starts and after restart.
+     */
+    subscribe(eventBus: AgentEventBus): void;
+    /**
+     * Optional cleanup method called when unsubscribing.
+     */
+    unsubscribe?(): void;
+}
+export type { AgentConfig, BlobStorageConfig, FileSystemConfig, LLMConfig, LLMUpdates, SessionConfig, ValidatedAgentConfig, ValidatedBlobStorageConfig, ValidatedFileSystemConfig, ValidatedLLMConfig, ValidatedSessionConfig, } from './agent-schemas.js';

package/dist/infra/cipher/agent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/infra/cipher/blob/blob-reference-resolver.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Blob reference resolver for lazy media evaluation.
+ *
+ * This service resolves @blob:id references in message content to actual data
+ * at format-time (when sending to LLM), enabling lazy evaluation of large media.
+ *
+ * Key features:
+ * - Lazy expansion: Blob references only resolved when needed
+ * - MIME type filtering: Exclude unsupported media types
+ * - Placeholder generation: Replace filtered media with descriptive placeholders
+ *
+ */
+import type { IBlobStorage } from '../../../core/interfaces/cipher/i-blob-storage.js';
+import type { MessagePart } from '../../../core/interfaces/cipher/message-types.js';
+/**
+ * Options for blob reference expansion.
+ */
+export interface BlobResolutionOptions {
+    /**
+     * MIME patterns to allow (e.g., ["image/*", "application/pdf"]).
+     * Media not matching any pattern will be replaced with placeholders.
+     * If not specified, all media types are allowed.
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * Whether to include metadata in resolved parts.
+     * Default: false
+     */
+    includeMetadata?: boolean;
+}
+/**
+ * Result of resolving a single blob reference.
+ */
+export interface ResolvedBlobResult {
+    /** Error message if resolution failed */
+    error?: string;
+    /** Resolved message parts (may be multiple if embedded in text) */
+    parts: MessagePart[];
+    /** Whether resolution was successful */
+    success: boolean;
+}
+/**
+ * Blob reference resolver.
+ *
+ * Resolves @blob:id references to actual content at format-time.
+ */
+export declare class BlobReferenceResolver {
+    private readonly blobStorage;
+    constructor(blobStorage: IBlobStorage);
+    /**
+     * Expand blob references in message content.
+     *
+     * Processes an array of message parts and resolves any @blob:id references
+     * to actual content. Supports blob refs in:
+     * - TextPart.text (inline references)
+     * - ImagePart.image (blob ref instead of base64)
+     * - FilePart.data (blob ref instead of base64)
+     *
+     * @param content - Array of message parts to expand
+     * @param options - Resolution options
+     * @returns Array of message parts with blob refs resolved
+     */
+    expandBlobReferences(content: MessagePart[], options?: BlobResolutionOptions): Promise<MessagePart[]>;
+    /**
+     * Get all blob IDs referenced in content.
+     */
+    getBlobIds(content: MessagePart[]): string[];
+    /**
+     * Check if content contains any blob references.
+     *
+     * Useful for determining if expansion is needed before calling expandBlobReferences.
+     */
+    hasAnyBlobReferences(content: MessagePart[]): boolean;
+    /**
+     * Prefetch blobs for a set of message parts.
+     *
+     * Useful for warming the cache before expansion.
+     */
+    prefetchBlobs(content: MessagePart[]): Promise<void>;
+    /**
+     * Expand blob references embedded in text.
+     *
+     * Text like "Here is the image: @blob:abc123" will be split into
+     * multiple parts: text before, image part, text after.
+     */
+    private expandBlobsInText;
+    /**
+     * Expand a single message part.
+     */
+    private expandPart;
+    /**
+     * Resolve a blob ID to message parts.
+     */
+    private resolveBlobToParts;
+    /**
+     * Resolve a file part with blob reference.
+     */
+    private resolveFileBlob;
+    /**
+     * Resolve an image part with blob reference.
+     */
+    private resolveImageBlob;
+}
+/**
+ * Create a BlobReferenceResolver instance.
+ */
+export declare function createBlobReferenceResolver(blobStorage: IBlobStorage): BlobReferenceResolver;