byterover-cli 0.2.1 → 0.3.0

package/dist/hooks/command_not_found/handle-invalid-commands.d.ts

@@ -0,0 +1,7 @@
+import type { Hook } from '@oclif/core';
+/**
+ * Hook to handle command not found errors
+ * Provides helpful error messages when users type invalid commands or subcommands
+ */
+declare const hook: Hook<'command_not_found'>;
+export default hook;

package/dist/hooks/command_not_found/handle-invalid-commands.js

@@ -0,0 +1,32 @@
+/**
+ * Hook to handle command not found errors
+ * Provides helpful error messages when users type invalid commands or subcommands
+ */
+const hook = async function (options) {
+    const { id } = options;
+    // Check if it's a cipher-agent subcommand typo
+    if (id?.startsWith('cipher-agent:')) {
+        const invalidSubcommand = id.replace('cipher-agent:', '');
+        this.log();
+        this.log(`Unknown cipher-agent command: "${invalidSubcommand}"`);
+        this.log();
+        this.log('USAGE');
+        this.log('  $ brv cipher-agent COMMAND');
+        this.log();
+        this.log('COMMANDS');
+        this.log('  cipher-agent run          Run CipherAgent in interactive or single-execution mode');
+        this.log('  cipher-agent set-prompt   Set custom system prompt for CipherAgent');
+        this.log('  cipher-agent show-prompt  Show the current CipherAgent system prompt');
+        this.log();
+        // Exit with error code
+        this.exit(1);
+    }
+    // Default error message for other commands
+    this.log();
+    this.log(`Command "${id}" not found`);
+    this.log();
+    this.log('Run "brv --help" to see available commands');
+    this.log();
+    this.exit(1);
+};
+export default hook;

package/dist/hooks/error/clean-errors.d.ts

@@ -0,0 +1,7 @@
+import type { Hook } from '@oclif/core';
+/**
+ * Hook to handle errors and provide clean error messages
+ * Hides stack traces for user-facing errors
+ */
+declare const hook: Hook<'error'>;
+export default hook;

package/dist/hooks/error/clean-errors.js

@@ -0,0 +1,50 @@
+/**
+ * Hook to handle errors and provide clean error messages
+ * Hides stack traces for user-facing errors
+ */
+const hook = async function (options) {
+    const { error } = options;
+    // Type guard for Error objects
+    if (!(error instanceof Error)) {
+        return;
+    }
+    // Suppress oclif's default error output (stack traces)
+    // Type assertion needed to delete dynamic property
+    delete error.oclif;
+    // Handle validation errors (missing args, invalid flags, etc.)
+    if (error.message.includes('Missing') && error.message.includes('required arg')) {
+        // Extract the clean error message without stack trace
+        const lines = error.message.split('\n');
+        const errorLine = lines[0];
+        const argLine = lines[1];
+        // Use process.stderr.write to avoid oclif formatting (no › prefix)
+        process.stderr.write('\n');
+        process.stderr.write(errorLine + '\n');
+        if (argLine) {
+            process.stderr.write(argLine + '\n');
+        }
+        process.stderr.write('\n');
+        process.stderr.write('See more help with --help\n');
+        process.stderr.write('\n');
+        // Prevent default error handling
+        this.exit(2);
+    }
+    // For user-facing errors (network, auth, etc.), show clean message only
+    // Check if error is already formatted with emoji prefix (❌, ⚠️, etc.)
+    const isUserFacingError = error.message.startsWith('❌') || error.message.startsWith('⚠️') || error.message.includes('Network error');
+    if (isUserFacingError) {
+        // Just show the clean error message, no "See more help"
+        process.stderr.write('\n');
+        process.stderr.write(error.message + '\n');
+        process.stderr.write('\n');
+        this.exit(1);
+    }
+    // For other errors (unknown errors), show message + help hint
+    process.stderr.write('\n');
+    process.stderr.write(error.message + '\n');
+    process.stderr.write('\n');
+    process.stderr.write('See more help with --help\n');
+    process.stderr.write('\n');
+    this.exit(1);
+};
+export default hook;

package/dist/hooks/init/welcome.js

@@ -1,6 +1,72 @@
 import chalk from 'chalk';
 import { DOCS_URL } from '../../constants.js';
+/**
+ * Validates Node.js version compatibility
+ * @returns Error message if incompatible, warning message if untested, null if compatible
+ */
+function checkNodeVersion() {
+    const nodeVersion = process.version;
+    const versionMatch = nodeVersion.match(/^v(\d+)\.(\d+)\.(\d+)/);
+    if (!versionMatch) {
+        return {
+            message: `Unable to determine Node.js version. Current version: ${nodeVersion}`,
+            type: 'warning',
+        };
+    }
+    const [, major, minor] = versionMatch;
+    const majorVersion = Number.parseInt(major, 10);
+    const minorVersion = Number.parseInt(minor, 10);
+    // Minimum supported version: Node 18
+    if (majorVersion < 18) {
+        return {
+            message: `Node.js ${majorVersion}.${minorVersion} is not supported.\n` +
+                'ByteRover CLI requires Node.js 18 or higher.\n' +
+                `Current version: ${nodeVersion}\n\n` +
+                'Please upgrade Node.js:\n' +
+                '  - Using nvm: nvm install 22 && nvm use 22\n' +
+                '  - Download from: https://nodejs.org/',
+            type: 'error',
+        };
+    }
+    // Recommended versions: Node 18, 20, 22
+    // Node 24+ may have compatibility issues with native modules (better-sqlite3, grpc)
+    if (majorVersion >= 24) {
+        return {
+            message: `Node.js ${majorVersion}.${minorVersion} has not been fully tested with ByteRover CLI.\n` +
+                `Current version: ${nodeVersion}\n` +
+                'Recommended versions: Node.js 18.x, 20.x, or 22.x (LTS)\n\n' +
+                'Some native dependencies (sqlite, grpc) may not work correctly.\n' +
+                'If you encounter errors, please switch to a recommended version:\n' +
+                '  - Using nvm: nvm install 22 && nvm use 22',
+            type: 'warning',
+        };
+    }
+    // All checks passed
+    return null;
+}
 const hook = async function (options) {
+    // Check Node.js version compatibility first
+    const versionCheck = checkNodeVersion();
+    if (versionCheck) {
+        if (versionCheck.type === 'error') {
+            // Critical error - incompatible Node version
+            // Use process.stderr to show clean error without stack trace
+            process.stderr.write('\n');
+            process.stderr.write(chalk.red('❌ Incompatible Node.js version\n\n'));
+            process.stderr.write(versionCheck.message);
+            process.stderr.write('\n\n');
+            // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+            process.exit(1);
+        }
+        else if (versionCheck.type === 'warning') {
+            // Warning - untested version, but allow to continue
+            // Use process.stderr to show clean warning without stack trace
+            process.stderr.write('\n');
+            process.stderr.write(chalk.yellow('⚠️  Node.js version warning\n\n'));
+            process.stderr.write(chalk.yellow(versionCheck.message));
+            process.stderr.write('\n\n');
+        }
+    }
     // Detect root help commands only (not command-specific help)
     const isRootHelp = (options.id === undefined && options.argv.length === 0) || // bare `brv`
         (options.id === '--help' && options.argv.length === 0) || // `brv --help`
@@ -22,7 +88,12 @@ const hook = async function (options) {
             '  2. Link your workspace:',
             '     brv init',
             '',
-            'After setup, run `brv status` to confirm connection and explore commands like `brv retrieve` or `brv complete`.',
+            'After setup, run `brv status` to confirm your connection.',
+            '',
+            '  Explore commands:',
+            '    • `brv curate` - Organize and curate your context tree',
+            '    • `brv query` - Search and query your context tree',
+            '    • `brv push` - Push your context tree to ByteRover',
         ].join('\n');
         const docsLink = `For more information, run 'brv --help', 'brv [command] --help' or visit ${DOCS_URL}`;
         this.log(`\n${logo}\n\n${onboardingText}\n\n${docsLink}\n\n`);

package/dist/hooks/prerun/validate-brv-config-version.d.ts

@@ -0,0 +1,28 @@
+import type { Hook } from '@oclif/core';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+/**
+ * Commands that should skip config version validation.
+ * These commands either don't need config or create/recreate it.
+ */
+export declare const SKIP_COMMANDS: Set<string>;
+/**
+ * Context for hook error handling.
+ */
+type HookErrorContext = {
+    error: (message: string, options: {
+        exit: number;
+    }) => void;
+};
+/**
+ * Core validation logic extracted for testability.
+ * @param commandId - The command being executed
+ * @param configStore - The config store to use for reading config
+ * @param errorContext - Context with error function to call on version errors
+ */
+export declare const validateBrvConfigVersion: (commandId: string, configStore: IProjectConfigStore, errorContext: HookErrorContext) => Promise<void>;
+/**
+ * Prerun hook that validates the .brv/config.json version before command execution.
+ * Throws an error if the config version is missing or mismatched, prompting users to re-run `brv init`.
+ */
+declare const hook: Hook<'prerun'>;
+export default hook;

package/dist/hooks/prerun/validate-brv-config-version.js

@@ -0,0 +1,43 @@
+import { BrvConfigVersionError } from '../../core/domain/errors/brv-config-version-error.js';
+import { ProjectConfigStore } from '../../infra/config/file-config-store.js';
+/**
+ * Commands that should skip config version validation.
+ * These commands either don't need config or create/recreate it.
+ */
+export const SKIP_COMMANDS = new Set(['--help', 'help', 'init', 'login', 'logout']);
+/**
+ * Core validation logic extracted for testability.
+ * @param commandId - The command being executed
+ * @param configStore - The config store to use for reading config
+ * @param errorContext - Context with error function to call on version errors
+ */
+export const validateBrvConfigVersion = async (commandId, configStore, errorContext) => {
+    // Skip version check for commands that don't need config
+    if (SKIP_COMMANDS.has(commandId)) {
+        return;
+    }
+    try {
+        // If config doesn't exist, let the command handle it
+        const exists = await configStore.exists();
+        if (!exists) {
+            return;
+        }
+        // read() will throw BrvConfigVersionError if version is invalid
+        await configStore.read();
+    }
+    catch (error) {
+        if (error instanceof BrvConfigVersionError) {
+            errorContext.error(error.message, { exit: 1 });
+        }
+        // Re-throw other errors (corrupted JSON, etc.)
+        throw error;
+    }
+};
+/**
+ * Prerun hook that validates the .brv/config.json version before command execution.
+ * Throws an error if the config version is missing or mismatched, prompting users to re-run `brv init`.
+ */
+const hook = async function (options) {
+    await validateBrvConfigVersion(options.Command.id, new ProjectConfigStore(), this);
+};
+export default hook;

package/dist/infra/cipher/agent-service-factory.d.ts

@@ -0,0 +1,86 @@
+import type { BlobStorageConfig } from '../../core/domain/cipher/blob/types.js';
+import type { FileSystemConfig } from '../../core/domain/cipher/file-system/types.js';
+import type { CipherAgentServices, SessionServices } from '../../core/interfaces/cipher/cipher-services.js';
+/**
+ * LLM configuration for CipherAgent
+ */
+export interface CipherLLMConfig {
+    accessToken: string;
+    apiKey?: string;
+    blobStorageConfig?: Partial<BlobStorageConfig>;
+    fileSystemConfig?: Partial<FileSystemConfig>;
+    grpcEndpoint: string;
+    httpReferer?: string;
+    maxIterations?: number;
+    maxTokens?: number;
+    model: string;
+    openRouterApiKey?: string;
+    projectId: string;
+    region?: string;
+    sessionKey: string;
+    siteName?: string;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    verbose?: boolean;
+}
+/**
+ * gRPC configuration for ByteRover LLM service
+ */
+export interface ByteRoverGrpcConfig {
+    accessToken: string;
+    grpcEndpoint: string;
+    projectId: string;
+    region?: string;
+    sessionKey: string;
+    spaceId: string;
+    teamId: string;
+    timeout?: number;
+}
+export type { CipherAgentServices, SessionManagerConfig, SessionServices, } from '../../core/interfaces/cipher/cipher-services.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.
+ *
+ * @param llmConfig - LLM configuration
+ * @returns Initialized shared services
+ */
+export declare function createCipherAgentServices(llmConfig: CipherLLMConfig): Promise<CipherAgentServices>;
+/**
+ * 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
+ * 3. LoggingContentGenerator - debug logging (if verbose enabled)
+ *
+ * @param sessionId - Unique session identifier
+ * @param sharedServices - Shared services from agent
+ * @param grpcConfig - gRPC 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 declare function createSessionServices(sessionId: string, sharedServices: CipherAgentServices, grpcConfig: ByteRoverGrpcConfig, llmConfig: {
+    httpReferer?: string;
+    maxIterations?: number;
+    maxTokens?: number;
+    model: string;
+    openRouterApiKey?: string;
+    siteName?: string;
+    temperature?: number;
+    verbose?: boolean;
+}): SessionServices;

package/dist/infra/cipher/agent-service-factory.js

@@ -0,0 +1,212 @@
+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 { ByteRoverLlmGrpcService } from './grpc/internal-llm-grpc-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 { 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';
+/**
+ * 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.
+ *
+ * @param llmConfig - LLM configuration
+ * @returns Initialized shared services
+ */
+export async function createCipherAgentServices(llmConfig) {
+    // 1. Agent event bus (global)
+    const agentEventBus = new AgentEventBus();
+    // 2. Logger (depends on event bus)
+    const logger = new EventBasedLogger(agentEventBus, 'CipherAgent');
+    // 3. File system service (no dependencies)
+    const fileSystemService = new FileSystemService(llmConfig.fileSystemConfig);
+    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();
+    const processService = new ProcessService({
+        allowedCommands: [],
+        blockedCommands: [],
+        environment: {},
+        maxConcurrentProcesses: 5,
+        maxOutputBuffer: 1_048_576, // 1MB (1024 * 1024)
+        maxTimeout: 600_000, // 10 minutes
+        securityLevel: 'permissive', // Permissive mode: relies on working directory confinement
+        workingDirectory,
+    });
+    await processService.initialize();
+    // 5. Blob storage (no dependencies)
+    // Always uses SQLite for performance and ACID transactions
+    const blobStorage = createBlobStorage(llmConfig.blobStorageConfig ?? {
+        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)
+    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)
+    const toolProvider = new ToolProvider({
+        fileSystemService,
+        memoryManager,
+        processService,
+    }, promptFactory);
+    await toolProvider.initialize();
+    // 8. Policy engine with default rules for autonomous execution
+    const policyEngine = new PolicyEngine({ defaultDecision: 'ALLOW' });
+    policyEngine.addRules(DEFAULT_POLICY_RULES);
+    // 9. Tool scheduler (orchestrates policy check → execution)
+    const toolScheduler = new CoreToolScheduler(toolProvider, policyEngine, undefined, {
+        verbose,
+    });
+    // 10. Tool manager (with scheduler for policy-based execution)
+    const toolManager = new ToolManager(toolProvider, toolScheduler);
+    await toolManager.initialize();
+    // 11. History storage (depends on BlobStorage) - SHARED across sessions
+    const historyStorage = new BlobHistoryStorage(blobStorage);
+    // Log successful initialization
+    logger.info('CipherAgent services initialized successfully', {
+        model: llmConfig.model,
+        verbose: llmConfig.verbose,
+        workingDirectory,
+    });
+    return {
+        agentEventBus,
+        blobStorage,
+        fileSystemService,
+        historyStorage,
+        memoryManager,
+        policyEngine,
+        processService,
+        promptFactory,
+        toolManager,
+        toolProvider,
+        toolScheduler,
+    };
+}
+/**
+ * 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
+ * 3. LoggingContentGenerator - debug logging (if verbose enabled)
+ *
+ * @param sessionId - Unique session identifier
+ * @param sharedServices - Shared services from agent
+ * @param grpcConfig - gRPC 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, grpcConfig, llmConfig) {
+    // 1. Create session-specific event bus
+    const sessionEventBus = new SessionEventBus();
+    // 2. Create session-scoped logger
+    const sessionLogger = new EventBasedLogger(sharedServices.agentEventBus, 'LLMService', sessionId);
+    // 3. Create LLM service based on configuration
+    // Priority: OpenRouter > ByteRover gRPC
+    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,
+            maxIterations: llmConfig.maxIterations ?? 50,
+            maxTokens: llmConfig.maxTokens ?? 8192,
+            model: llmConfig.model ?? 'google/gemini-2.5-pro',
+            siteName: llmConfig.siteName,
+            temperature: llmConfig.temperature ?? 0.7,
+            verbose: llmConfig.verbose ?? false,
+        }, {
+            logger: sessionLogger,
+            memoryManager: sharedServices.memoryManager, // SHARED
+            sessionEventBus,
+            systemPromptManager: sharedServices.promptFactory, // SHARED
+            toolManager: sharedServices.toolManager, // SHARED
+        });
+    }
+    else {
+        // Use gRPC backend service (default) with new generator pattern
+        // Step 1: Create gRPC service
+        const grpcService = new ByteRoverLlmGrpcService({
+            accessToken: grpcConfig.accessToken,
+            grpcEndpoint: grpcConfig.grpcEndpoint,
+            projectId: grpcConfig.projectId,
+            region: grpcConfig.region,
+            sessionKey: grpcConfig.sessionKey,
+            spaceId: grpcConfig.spaceId,
+            teamId: grpcConfig.teamId,
+            timeout: grpcConfig.timeout,
+        });
+        // Step 2: Create base content generator
+        let generator = new ByteRoverContentGenerator(grpcService, {
+            maxTokens: llmConfig.maxTokens ?? 8192,
+            model: llmConfig.model ?? 'gemini-2.5-pro',
+            temperature: llmConfig.temperature ?? 0.7,
+        });
+        // Step 3: Wrap with retry decorator
+        generator = new RetryableContentGenerator(generator, {
+            eventBus: sessionEventBus,
+            policy: DEFAULT_RETRY_POLICY,
+        });
+        // Step 4: Wrap with logging decorator (always, for spinner events)
+        generator = new LoggingContentGenerator(generator, sessionEventBus, {
+            logChunks: llmConfig.verbose,
+            logRequests: llmConfig.verbose,
+            logResponses: llmConfig.verbose,
+            verbose: llmConfig.verbose,
+        });
+        // Step 5: Create LLM service with composed generator
+        llmService = new ByteRoverLLMService(sessionId, generator, {
+            maxIterations: llmConfig.maxIterations ?? 50,
+            maxTokens: llmConfig.maxTokens ?? 8192,
+            model: llmConfig.model ?? 'gemini-2.5-pro',
+            temperature: llmConfig.temperature ?? 0.7,
+            verbose: llmConfig.verbose ?? false,
+        }, {
+            historyStorage: sharedServices.historyStorage, // SHARED
+            logger: sessionLogger,
+            memoryManager: sharedServices.memoryManager, // SHARED
+            promptFactory: sharedServices.promptFactory, // SHARED
+            sessionEventBus,
+            toolManager: sharedServices.toolManager, // SHARED
+        });
+    }
+    // Event forwarding is handled by ChatSession.setupEventForwarding()
+    // to ensure proper cleanup when sessions are disposed
+    return {
+        llmService,
+        sessionEventBus,
+    };
+}

package/dist/infra/cipher/blob/blob-storage-factory.d.ts

@@ -0,0 +1,13 @@
+import type { BlobStorageConfig } from '../../../core/domain/cipher/blob/types.js';
+import type { IBlobStorage } from '../../../core/interfaces/cipher/i-blob-storage.js';
+/**
+ * Factory function to create blob storage backend.
+ * Always uses SQLite for better performance, single file, and ACID transactions.
+ *
+ * @param config - Blob storage configuration
+ * @returns SQLite blob storage implementation
+ *
+ * @example
+ * const storage = createBlobStorage({ storageDir: '.brv/blobs' });
+ */
+export declare function createBlobStorage(config?: Partial<BlobStorageConfig>): IBlobStorage;

package/dist/infra/cipher/blob/blob-storage-factory.js

@@ -0,0 +1,14 @@
+import { SqliteBlobStorage } from './sqlite-blob-storage.js';
+/**
+ * Factory function to create blob storage backend.
+ * Always uses SQLite for better performance, single file, and ACID transactions.
+ *
+ * @param config - Blob storage configuration
+ * @returns SQLite blob storage implementation
+ *
+ * @example
+ * const storage = createBlobStorage({ storageDir: '.brv/blobs' });
+ */
+export function createBlobStorage(config) {
+    return new SqliteBlobStorage(config);
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Blob storage module
+ * Provides persistent storage for binary/large data blobs using SQLite
+ */
+export type { BlobMetadata, BlobStats, BlobStorageConfig, StoredBlob } from '../../../core/domain/cipher/blob/types.js';
+export { BlobError, BlobErrorCode } from '../../../core/domain/cipher/errors/blob-error.js';
+export type { IBlobStorage } from '../../../core/interfaces/cipher/i-blob-storage.js';
+export { createBlobStorage } from './blob-storage-factory.js';
+export * as BlobMigrations from './migrations.js';
+export { SqliteBlobStorage } from './sqlite-blob-storage.js';

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

@@ -0,0 +1,12 @@
+/**
+ * Blob storage module
+ * Provides persistent storage for binary/large data blobs using SQLite
+ */
+// Re-export errors from core
+export { BlobError, BlobErrorCode } from '../../../core/domain/cipher/errors/blob-error.js';
+// Factory (always returns SQLite implementation)
+export { createBlobStorage } from './blob-storage-factory.js';
+// Migration system
+export * as BlobMigrations from './migrations.js';
+// SQLite storage implementation
+export { SqliteBlobStorage } from './sqlite-blob-storage.js';