byterover-cli 0.2.0 → 0.3.0

package/dist/infra/cipher/logger/event-based-logger.js

@@ -0,0 +1,92 @@
+/**
+ * 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 class EventBasedLogger {
+    eventBus;
+    source;
+    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, source, sessionId) {
+        this.eventBus = eventBus;
+        this.source = source;
+        this.sessionId = sessionId;
+    }
+    debug(message, context) {
+        this.eventBus.emit('cipher:log', {
+            context,
+            level: 'debug',
+            message,
+            sessionId: this.sessionId,
+            source: this.source,
+        });
+    }
+    error(message, context) {
+        this.eventBus.emit('cipher:log', {
+            context,
+            level: 'error',
+            message,
+            sessionId: this.sessionId,
+            source: this.source,
+        });
+    }
+    info(message, context) {
+        this.eventBus.emit('cipher:log', {
+            context,
+            level: 'info',
+            message,
+            sessionId: this.sessionId,
+            source: this.source,
+        });
+    }
+    warn(message, context) {
+        this.eventBus.emit('cipher:log', {
+            context,
+            level: 'warn',
+            message,
+            sessionId: this.sessionId,
+            source: this.source,
+        });
+    }
+    /**
+     * 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) {
+        return new EventBasedLogger(this.eventBus, this.source, sessionId);
+    }
+    /**
+     * 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) {
+        return new EventBasedLogger(this.eventBus, source, this.sessionId);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,136 @@
+import type { StoredBlob } from '../../../core/domain/cipher/blob/types.js';
+import type { Attachment, CreateMemoryInput, ListMemoriesOptions, Memory, UpdateMemoryInput } from '../../../core/domain/cipher/memory/types.js';
+import type { IBlobStorage } from '../../../core/interfaces/cipher/i-blob-storage.js';
+import type { ILogger } from '../../../core/interfaces/cipher/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;
+}