byterover-cli 1.6.0 → 1.7.1

package/dist/agent/infra/llm/transformers/openrouter-stream-transformer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * OpenRouter Stream Transformer
+ *
+ * Transforms OpenRouter/OpenAI streaming chunks (GenerateContentChunk)
+ * into StreamEvent format compatible with StreamProcessor.
+ *
+ * This follows the OpenCode pattern of delta-based streaming events
+ * for real-time UI updates.
+ *
+ * Supports multiple reasoning extraction methods:
+ * 1. Native reasoning fields (OpenAI o1/o3, Grok, Gemini) - via rawChunk
+ * 2. Pre-extracted reasoning (from content generator) - via chunk.reasoning
+ * 3. <think> tags in content (Claude, DeepSeek, MiniMax) - via tag extraction
+ *
+ * Following OpenCode's extractReasoningMiddleware pattern.
+ */
+import type { StreamEvent } from '../stream-processor.js';
+import { GenerateContentChunk } from '../../../core/interfaces/i-content-generator.js';
+/**
+ * Options for stream transformation
+ */
+export interface TransformOptions {
+    /** Model ID for capability detection (e.g., 'openai/o3-mini', 'anthropic/claude-3-opus') */
+    modelId?: string;
+    /** Current step index for step events */
+    stepIndex?: number;
+}
+/**
+ * Transform GenerateContentChunk stream into StreamEvent stream.
+ *
+ * Maps the chunk format from OpenRouterContentGenerator to the
+ * StreamEvent format expected by StreamProcessor:
+ *
+ * - content (delta) → { type: 'text-delta', delta } or { type: 'reasoning-delta', delta }
+ * - reasoning (native) → { type: 'reasoning-start/delta-v2/end' } (for OpenAI, Grok, Gemini)
+ * - toolCalls → { type: 'tool-call-start' }, { type: 'tool-call-input' }
+ * - finishReason → { type: 'step-finish', ... }
+ * - isComplete → { type: 'finish' }
+ *
+ * Supports multiple reasoning extraction methods:
+ * 1. Native reasoning fields (OpenAI o1/o3, Grok, Gemini) - checked first
+ * 2. Pre-extracted reasoning from chunk.reasoning
+ * 3. <think> tags in content (Claude, DeepSeek, MiniMax) - fallback
+ *
+ * @param chunks - Async generator of GenerateContentChunk from content generator
+ * @param options - Transform options including modelId for capability detection
+ * @yields StreamEvent objects for StreamProcessor
+ */
+export declare function transformGenerateContentChunksToStreamEvents(chunks: AsyncGenerator<GenerateContentChunk>, options?: TransformOptions): AsyncGenerator<StreamEvent>;

package/dist/agent/infra/llm/transformers/openrouter-stream-transformer.js

@@ -0,0 +1,270 @@
+/**
+ * OpenRouter Stream Transformer
+ *
+ * Transforms OpenRouter/OpenAI streaming chunks (GenerateContentChunk)
+ * into StreamEvent format compatible with StreamProcessor.
+ *
+ * This follows the OpenCode pattern of delta-based streaming events
+ * for real-time UI updates.
+ *
+ * Supports multiple reasoning extraction methods:
+ * 1. Native reasoning fields (OpenAI o1/o3, Grok, Gemini) - via rawChunk
+ * 2. Pre-extracted reasoning (from content generator) - via chunk.reasoning
+ * 3. <think> tags in content (Claude, DeepSeek, MiniMax) - via tag extraction
+ *
+ * Following OpenCode's extractReasoningMiddleware pattern.
+ */
+import { getModelCapabilities } from '../model-capabilities.js';
+import { extractReasoning } from './reasoning-extractor.js';
+/**
+ * Process text content to extract <think> tags and separate reasoning from text.
+ * Returns events to emit based on the content analysis.
+ *
+ * @param content - Raw text content from chunk
+ * @param state - Mutable state for tracking think tag parsing across chunks
+ * @returns Array of StreamEvents to emit
+ */
+function processContentForThinkTags(content, state) {
+    const events = [];
+    let remaining = content;
+    let textBuffer = '';
+    while (remaining.length > 0) {
+        if (state.insideThinkTag) {
+            // Look for closing </think> tag
+            const closeIndex = remaining.indexOf('</think>');
+            if (closeIndex === -1) {
+                // No closing tag yet - buffer everything
+                state.buffer += remaining;
+                remaining = '';
+            }
+            else {
+                // Found closing tag - emit buffered reasoning
+                const reasoningContent = state.buffer + remaining.slice(0, closeIndex);
+                if (reasoningContent) {
+                    events.push({ delta: reasoningContent, type: 'reasoning-delta' });
+                }
+                state.buffer = '';
+                state.insideThinkTag = false;
+                remaining = remaining.slice(closeIndex + 8); // Skip past </think>
+            }
+        }
+        else {
+            // Look for opening <think> tag
+            const openIndex = remaining.indexOf('<think>');
+            if (openIndex === -1) {
+                // No think tag - check for partial tag at end
+                // Look for potential start of <think> at the end
+                let partialTagLength = 0;
+                for (let i = 1; i <= Math.min(6, remaining.length); i++) {
+                    const suffix = remaining.slice(-i);
+                    if ('<think>'.startsWith(suffix)) {
+                        partialTagLength = i;
+                    }
+                }
+                if (partialTagLength > 0) {
+                    // Buffer the potential partial tag, emit the rest as text
+                    textBuffer += remaining.slice(0, -partialTagLength);
+                    state.buffer = remaining.slice(-partialTagLength);
+                }
+                else {
+                    textBuffer += remaining;
+                }
+                remaining = '';
+            }
+            else {
+                // Found opening tag - emit any text before it
+                const textBefore = remaining.slice(0, openIndex);
+                if (textBefore) {
+                    textBuffer += textBefore;
+                }
+                state.insideThinkTag = true;
+                state.buffer = '';
+                remaining = remaining.slice(openIndex + 7); // Skip past <think>
+            }
+        }
+    }
+    // Emit accumulated text content
+    if (textBuffer) {
+        events.push({ delta: textBuffer, type: 'text-delta' });
+    }
+    return events;
+}
+/**
+ * Transform GenerateContentChunk stream into StreamEvent stream.
+ *
+ * Maps the chunk format from OpenRouterContentGenerator to the
+ * StreamEvent format expected by StreamProcessor:
+ *
+ * - content (delta) → { type: 'text-delta', delta } or { type: 'reasoning-delta', delta }
+ * - reasoning (native) → { type: 'reasoning-start/delta-v2/end' } (for OpenAI, Grok, Gemini)
+ * - toolCalls → { type: 'tool-call-start' }, { type: 'tool-call-input' }
+ * - finishReason → { type: 'step-finish', ... }
+ * - isComplete → { type: 'finish' }
+ *
+ * Supports multiple reasoning extraction methods:
+ * 1. Native reasoning fields (OpenAI o1/o3, Grok, Gemini) - checked first
+ * 2. Pre-extracted reasoning from chunk.reasoning
+ * 3. <think> tags in content (Claude, DeepSeek, MiniMax) - fallback
+ *
+ * @param chunks - Async generator of GenerateContentChunk from content generator
+ * @param options - Transform options including modelId for capability detection
+ * @yields StreamEvent objects for StreamProcessor
+ */
+export async function* transformGenerateContentChunksToStreamEvents(chunks, options = {}) {
+    const { modelId = '', stepIndex = 0 } = options;
+    const capabilities = getModelCapabilities(modelId);
+    // Track tool calls that have been started
+    const startedToolCalls = new Set();
+    // State for think tag extraction (fallback for think-tags format)
+    const thinkState = {
+        buffer: '',
+        insideThinkTag: false,
+    };
+    // State for native reasoning tracking
+    let activeReasoningId;
+    let reasoningStarted = false;
+    // Emit step start
+    yield {
+        stepIndex,
+        type: 'step-start',
+    };
+    for await (const chunk of chunks) {
+        let reasoningHandled = false;
+        // Priority 1: Check for native reasoning in rawChunk (for models with native-field format)
+        if (capabilities.reasoningFormat === 'native-field' && chunk.rawChunk) {
+            const reasoningResult = extractReasoning(chunk.rawChunk, modelId);
+            if (reasoningResult.reasoning) {
+                reasoningHandled = true;
+                // Emit reasoning-start if this is the first reasoning chunk
+                if (!reasoningStarted && reasoningResult.reasoningId) {
+                    activeReasoningId = reasoningResult.reasoningId;
+                    reasoningStarted = true;
+                    yield {
+                        id: activeReasoningId,
+                        providerMetadata: reasoningResult.providerMetadata,
+                        type: 'reasoning-start',
+                    };
+                }
+                // Emit reasoning delta (using v2 format with ID tracking)
+                yield {
+                    delta: reasoningResult.reasoning,
+                    id: activeReasoningId ?? `reasoning-${Date.now()}`,
+                    providerMetadata: reasoningResult.providerMetadata,
+                    type: 'reasoning-delta-v2',
+                };
+            }
+            // Handle any text content extracted alongside reasoning
+            if (reasoningResult.content) {
+                yield { delta: reasoningResult.content, type: 'text-delta' };
+            }
+        }
+        // Priority 2: Check for pre-extracted reasoning in chunk (only if Priority 1 didn't handle it)
+        if (!reasoningHandled && chunk.reasoning) {
+            // Emit reasoning-start if this is the first reasoning chunk
+            if (!reasoningStarted) {
+                activeReasoningId = chunk.reasoningId ?? `reasoning-${Date.now()}`;
+                reasoningStarted = true;
+                yield {
+                    id: activeReasoningId,
+                    providerMetadata: chunk.providerMetadata,
+                    type: 'reasoning-start',
+                };
+            }
+            // Emit reasoning delta
+            yield {
+                delta: chunk.reasoning,
+                id: activeReasoningId ?? `reasoning-${Date.now()}`,
+                providerMetadata: chunk.providerMetadata,
+                type: 'reasoning-delta-v2',
+            };
+        }
+        // Priority 3: Handle text content - extract <think> tags for think-tags format
+        if (chunk.content) {
+            if (capabilities.reasoningFormat === 'think-tags') {
+                // Extract <think> tags for models that use them
+                const events = processContentForThinkTags(chunk.content, thinkState);
+                for (const event of events) {
+                    yield event;
+                }
+            }
+            else if (capabilities.reasoningFormat !== 'native-field') {
+                // For models without reasoning or already handled natively, emit as text
+                yield { delta: chunk.content, type: 'text-delta' };
+            }
+            else if (!chunk.rawChunk) {
+                // Native format but no rawChunk - fall back to think tag extraction
+                const events = processContentForThinkTags(chunk.content, thinkState);
+                for (const event of events) {
+                    yield event;
+                }
+            }
+        }
+        // Handle tool calls on final chunk
+        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+            for (const toolCall of chunk.toolCalls) {
+                const callId = toolCall.id;
+                // Emit tool-call-start if not already started
+                if (!startedToolCalls.has(callId)) {
+                    startedToolCalls.add(callId);
+                    yield {
+                        callId,
+                        toolName: toolCall.function.name,
+                        type: 'tool-call-start',
+                    };
+                }
+                // Emit tool-call-input with parsed arguments
+                try {
+                    const input = JSON.parse(toolCall.function.arguments);
+                    yield {
+                        callId,
+                        input,
+                        type: 'tool-call-input',
+                    };
+                }
+                catch {
+                    // If arguments can't be parsed, emit empty input
+                    yield {
+                        callId,
+                        input: {},
+                        type: 'tool-call-input',
+                    };
+                }
+            }
+        }
+        // Handle completion
+        if (chunk.isComplete) {
+            // Flush any remaining buffered content
+            if (thinkState.buffer) {
+                // Emit as reasoning if inside think tag, otherwise as text
+                yield thinkState.insideThinkTag
+                    ? { delta: thinkState.buffer, type: 'reasoning-delta' }
+                    : { delta: thinkState.buffer, type: 'text-delta' };
+                thinkState.buffer = '';
+            }
+            // Emit reasoning-end if we had active reasoning
+            if (reasoningStarted && activeReasoningId) {
+                yield {
+                    id: activeReasoningId,
+                    providerMetadata: chunk.providerMetadata,
+                    type: 'reasoning-end',
+                };
+            }
+            // Emit step finish with finish reason
+            const finishReason = chunk.finishReason === 'tool_calls' ? 'tool_calls' : chunk.finishReason === 'max_tokens' ? 'max_tokens' : 'stop';
+            yield {
+                cost: 0, // Cost calculated separately
+                finishReason,
+                stepIndex,
+                tokens: {
+                    input: 0, // Tokens updated after stream completes
+                    output: 0,
+                },
+                type: 'step-finish',
+            };
+            // Emit finish event
+            yield {
+                type: 'finish',
+            };
+        }
+    }
+}

package/dist/agent/infra/logger/console-logger.d.ts

@@ -0,0 +1,42 @@
+import type { ILogger } from '../../core/interfaces/i-logger.js';
+/**
+ * Console-based logger implementation.
+ *
+ * This is a concrete logger that writes to the console with color formatting.
+ * Used at the command/presentation layer to display logs to the user.
+ *
+ * Design principles:
+ * - Only used in command layer (not in domain/infrastructure)
+ * - Formats messages with chalk for better UX
+ * - Includes timestamps for debugging
+ * - Can be swapped with other implementations (file, remote, etc.)
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger({ verbose: true });
+ * logger.info('Server started', { port: 3000 });
+ * // Output: [2025-01-26 10:30:45] INFO: Server started {"port":3000}
+ * ```
+ */
+export declare class ConsoleLogger implements ILogger {
+    private readonly verbose;
+    /**
+     * Create a new console logger.
+     *
+     * @param options - Logger options
+     * @param options.verbose - Enable verbose (debug) output
+     */
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    debug(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Format current timestamp for log messages.
+     *
+     * @returns Formatted timestamp string (YYYY-MM-DD HH:MM:SS)
+     */
+    private formatTimestamp;
+}

package/dist/agent/infra/logger/event-based-logger.d.ts

@@ -0,0 +1,54 @@
+import type { ILogger } from '../../core/interfaces/i-logger.js';
+import type { AgentEventBus } from '../events/event-emitter.js';
+/**
+ * Event-based logger that emits cipher:log events instead of writing directly.
+ *
+ * This follows Clean Architecture by decoupling logging from infrastructure.
+ * The logger emits events that can be handled by any listener (console, file, remote, etc.).
+ *
+ * Design principles:
+ * - Domain/infrastructure layers use this logger
+ * - Events are emitted to AgentEventBus
+ * - Command layer listens to events and decides how to handle them
+ * - Supports optional source and sessionId for context tracking
+ *
+ * @example
+ * ```typescript
+ * const logger = new EventBasedLogger(agentBus, 'MyService');
+ * logger.info('User logged in', { userId: '123' });
+ * // Emits: cipher:log { level: 'info', message: '...', source: 'MyService', ... }
+ * ```
+ */
+export declare class EventBasedLogger implements ILogger {
+    private readonly eventBus;
+    private readonly source?;
+    private readonly sessionId?;
+    /**
+     * Create a new event-based logger.
+     *
+     * @param eventBus - Agent event bus to emit log events to
+     * @param source - Optional source identifier (e.g., class name)
+     * @param sessionId - Optional session ID for session-scoped logs
+     */
+    constructor(eventBus: AgentEventBus, source?: string | undefined, sessionId?: string | undefined);
+    debug(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Create a child logger with a different session ID.
+     * Useful for creating session-scoped loggers.
+     *
+     * @param sessionId - Session ID for the child logger
+     * @returns New logger instance with the specified session ID
+     */
+    withSessionId(sessionId: string): EventBasedLogger;
+    /**
+     * Create a child logger with a different source.
+     * Useful for creating component-scoped loggers.
+     *
+     * @param source - Source identifier for the child logger
+     * @returns New logger instance with the specified source
+     */
+    withSource(source: string): EventBasedLogger;
+}

package/dist/agent/infra/memory/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cipher memory module exports
+ */
+export { MemoryError, MemoryErrorCode } from '../../core/domain/errors/memory-error.js';
+export type { CreateMemoryInput, ListMemoriesOptions, Memory, MemoryConfig, MemorySource, UpdateMemoryInput, } from '../../core/domain/memory/types.js';
+export { MemoryManager } from './memory-manager.js';

package/dist/agent/infra/memory/index.js

@@ -0,0 +1,7 @@
+/**
+ * Cipher memory module exports
+ */
+// Re-export errors for convenience
+export { MemoryError, MemoryErrorCode } from '../../core/domain/errors/memory-error.js';
+// Manager
+export { MemoryManager } from './memory-manager.js';

package/dist/agent/infra/memory/memory-manager.d.ts

@@ -0,0 +1,136 @@
+import type { StoredBlob } from '../../core/domain/blob/types.js';
+import type { Attachment, CreateMemoryInput, ListMemoriesOptions, Memory, UpdateMemoryInput } from '../../core/domain/memory/types.js';
+import type { IBlobStorage } from '../../core/interfaces/i-blob-storage.js';
+import type { ILogger } from '../../core/interfaces/i-logger.js';
+/**
+ * MemoryManager handles CRUD operations for cipher agent memories
+ *
+ * Responsibilities:
+ * - Store and retrieve memories using BlobStorage
+ * - Validate memory data using embedded Zod schemas
+ * - Generate unique IDs for memories
+ * - Filter and search memories by source and pinned status
+ * - Sort memories by recency (updatedAt descending)
+ * - Manage blob attachments
+ *
+ * Storage:
+ * - Memories are stored as JSON blobs with key pattern: memory-{id}
+ * - Attachments are stored as blobs with key pattern: memory-{id}-{suffix}
+ * - All persistence operations use BlobStorage
+ */
+export declare class MemoryManager {
+    private blobStorage;
+    private static readonly MEMORY_KEY_PREFIX;
+    private readonly logger;
+    constructor(blobStorage: IBlobStorage, logger?: ILogger);
+    /**
+     * Attach a blob to an existing memory
+     * @param memoryId - Memory ID to attach blob to
+     * @param content - Blob content (Buffer or string)
+     * @param metadata - Blob metadata
+     * @param metadata.name - Optional filename
+     * @param metadata.type - Optional MIME type
+     * @returns Attachment metadata
+     * @throws MemoryError if memory not found or attachment fails
+     */
+    attachBlob(memoryId: string, content: Buffer | string, metadata?: {
+        name?: string;
+        type?: string;
+    }): Promise<Attachment>;
+    /**
+     * Get count of total memories matching the filter criteria
+     * @param options - Query options for filtering
+     * @returns Number of memories matching the criteria
+     */
+    count(options?: ListMemoriesOptions): Promise<number>;
+    /**
+     * Create a new memory
+     * @param input - Memory creation input
+     * @returns Created memory with generated ID and timestamps
+     */
+    create(input: CreateMemoryInput): Promise<Memory>;
+    /**
+     * Delete a memory by ID
+     * Also deletes all associated blob attachments
+     * @param id - Memory ID to delete
+     * @throws MemoryError if ID is invalid or memory not found
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Detach (remove) a blob from a memory
+     * @param memoryId - Memory ID to detach blob from
+     * @param blobKey - Blob key to remove
+     * @throws MemoryError if memory not found or detachment fails
+     */
+    detachBlob(memoryId: string, blobKey: string): Promise<void>;
+    /**
+     * Get a memory by ID
+     * @param id - Memory ID to retrieve
+     * @returns Memory object
+     * @throws MemoryError if ID is invalid or memory not found
+     */
+    get(id: string): Promise<Memory>;
+    /**
+     * Get a blob attachment from a memory
+     * @param memoryId - Memory ID
+     * @param blobKey - Blob key to retrieve
+     * @returns Stored blob with content and metadata
+     * @throws MemoryError if memory not found or blob not found
+     */
+    getAttachment(memoryId: string, blobKey: string): Promise<StoredBlob>;
+    /**
+     * Check if a memory exists
+     * @param id - Memory ID to check
+     * @returns true if memory exists, false otherwise
+     */
+    has(id: string): Promise<boolean>;
+    /**
+     * List all memories with optional filtering, sorting, and pagination
+     * @param options - Query options for filtering and pagination
+     * @returns Array of memories matching the criteria
+     */
+    list(options?: ListMemoriesOptions): Promise<Memory[]>;
+    /**
+     * List all attachments for a memory
+     * @param memoryId - Memory ID
+     * @returns Array of attachment metadata
+     * @throws MemoryError if memory not found
+     */
+    listAttachments(memoryId: string): Promise<Attachment[]>;
+    /**
+     * Update an existing memory
+     * @param id - Memory ID to update
+     * @param input - Update input (partial)
+     * @returns Updated memory
+     * @throws MemoryError if ID is invalid or memory not found
+     */
+    update(id: string, input: UpdateMemoryInput): Promise<Memory>;
+    /**
+     * Delete a memory from blob storage
+     */
+    private deleteMemory;
+    /**
+     * Extract memory ID from blob key
+     */
+    private extractMemoryId;
+    /**
+     * Get the blob key for a memory
+     */
+    private getMemoryKey;
+    /**
+     * Check if a blob key is a memory key (not an attachment)
+     */
+    private isMemoryKey;
+    /**
+     * Load all memories from blob storage
+     */
+    private loadAllMemories;
+    /**
+     * Load a memory from blob storage
+     */
+    private loadMemory;
+    /**
+     * Save a memory to blob storage
+     */
+    private saveMemory;
+}