byterover-cli 0.3.4 → 0.4.0

package/dist/commands/watch.d.ts

@@ -1,6 +1,7 @@
 import { Command } from '@oclif/core';
 import type { IFileWatcherService } from '../core/interfaces/i-file-watcher-service.js';
 import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { ITerminal } from '../core/interfaces/i-terminal.js';
 export default class Watch extends Command {
     static description: string;
     static examples: string[];
@@ -10,6 +11,7 @@ export default class Watch extends Command {
         paths: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     static hidden: boolean;
+    protected terminal: ITerminal;
     private lastParseTime;
     private parsingInProgress;
     private pendingParse;

package/dist/commands/watch.js

@@ -3,6 +3,7 @@ import { isDevelopment } from '../config/environment.js';
 import { ProjectConfigStore } from '../infra/config/file-config-store.js';
 import { CleanParserServiceFactory } from '../infra/parsers/clean/clean-parser-service-factory.js';
 import { RawParserServiceFactory } from '../infra/parsers/raw/raw-parser-service-factory.js';
+import { OclifTerminal } from '../infra/terminal/oclif-terminal.js';
 import { FileWatcherService } from '../infra/watcher/file-watcher-service.js';
 export default class Watch extends Command {
     static description = 'Watch file system directories for changes and trigger parsing pipeline [Development only]';
@@ -30,21 +31,24 @@ export default class Watch extends Command {
         }),
     };
     static hidden = !isDevelopment();
+    terminal = {};
     lastParseTime = 0;
     parsingInProgress = false;
     pendingParse = false;
     createServices() {
+        this.terminal = new OclifTerminal(this);
         return {
             fileWatcherService: new FileWatcherService(),
             projectConfigStore: new ProjectConfigStore(),
         };
     }
     async run() {
-        if (!isDevelopment()) {
-            this.error('This command is only available in development environment');
-        }
         const { flags } = await this.parse(Watch);
         const { fileWatcherService, projectConfigStore } = this.createServices();
+        if (!isDevelopment()) {
+            this.terminal.error('This command is only available in development environment');
+            return;
+        }
         let paths = [];
         let ideConfig = null;
         // Use explicit paths if provided
@@ -60,7 +64,7 @@ export default class Watch extends Command {
                     if (config?.chatLogPath && config?.ide) {
                         paths = [config.chatLogPath];
                         ideConfig = config.ide;
-                        this.log(`ℹ Using chat log path from config (${config.ide})`);
+                        this.terminal.log(`ℹ Using chat log path from config (${config.ide})`);
                     }
                 }
             }
@@ -68,7 +72,7 @@ export default class Watch extends Command {
                 // Silently ignore config loading errors
             }
             if (paths.length === 0) {
-                this.error('No paths specified. Either:\n' +
+                this.terminal.error('No paths specified. Either:\n' +
                     '  1. Use --paths flag: brv watch --paths ./logs,./outputs\n' +
                     '  2. Run "brv init" to configure IDE and detect workspaces');
             }
@@ -76,28 +80,28 @@ export default class Watch extends Command {
         try {
             // Set up file event handler with parsing pipeline
             fileWatcherService.setFileEventHandler(async (event) => {
-                this.log(`[${event.type}] ${event.path}`);
+                this.terminal.log(`[${event.type}] ${event.path}`);
                 // Only trigger parsing if IDE is configured
                 if (ideConfig && (event.type === 'add' || event.type === 'change' || event.type === 'unlink')) {
                     this.pendingParse = true;
                     // Debounce parsing to avoid too frequent triggers
                     if (!this.parsingInProgress && Date.now() - this.lastParseTime > flags.debounce) {
                         this.triggerParsing(ideConfig, paths[0]).catch((error) => {
-                            this.warn(`⚠️ Parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                            this.terminal.warn(`⚠️ Parsing error: ${error instanceof Error ? error.message : String(error)}`);
                         });
                     }
                 }
             });
             await fileWatcherService.start(paths);
-            this.log(`\n🔍 Watching paths: ${paths.join(', ')}`);
+            this.terminal.log(`\n🔍 Watching paths: ${paths.join(', ')}`);
             if (ideConfig) {
-                this.log(`📊 Parsing pipeline enabled for: ${ideConfig}`);
+                this.terminal.log(`📊 Parsing pipeline enabled for: ${ideConfig}`);
             }
-            this.log('Press Ctrl+C to stop...\n');
+            this.terminal.log('Press Ctrl+C to stop...\n');
             await this.waitForShutdownSignal();
         }
         catch (error) {
-            this.error(error instanceof Error ? error.message : 'Unknown Error');
+            this.terminal.error(error instanceof Error ? error.message : 'Unknown Error');
         }
         finally {
             await fileWatcherService.stop();
@@ -106,7 +110,7 @@ export default class Watch extends Command {
     async waitForShutdownSignal() {
         return new Promise((resolve) => {
             const handleSignal = () => {
-                this.log('\nShutting down watcher...');
+                this.terminal.log('\nShutting down watcher...');
                 process.off('SIGINT', handleSignal);
                 process.off('SIGTERM', handleSignal);
                 resolve();
@@ -126,10 +130,10 @@ export default class Watch extends Command {
             // Normalize IDE name for factory
             // Validate IDE is supported
             if (!RawParserServiceFactory.isSupported(ide)) {
-                this.warn(`⚠️ Unsupported IDE: ${ide}`);
+                this.terminal.warn(`⚠️ Unsupported IDE: ${ide}`);
                 return;
             }
-            this.log('\n📥 Parsing triggered...');
+            this.terminal.log('\n📥 Parsing triggered...');
             // Raw parsing phase
             let isRawSuccess = false;
             try {
@@ -137,7 +141,7 @@ export default class Watch extends Command {
                 isRawSuccess = await RawParserServiceFactory.parseConversations(ide, chatLogPath);
             }
             catch (error) {
-                this.warn(`⚠️ Raw parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                this.terminal.warn(`⚠️ Raw parsing error: ${error instanceof Error ? error.message : String(error)}`);
                 return;
             }
             // Clean parsing phase (if enabled)
@@ -147,14 +151,14 @@ export default class Watch extends Command {
                     const rawOutputDir = `${process.cwd()}/.brv/logs/${ide}/raw`;
                     const cleanSessions = await CleanParserServiceFactory.parseConversations(ide, rawOutputDir);
                     if (cleanSessions.length > 0) {
-                        this.log('✅ Clean parsing complete\n');
+                        this.terminal.log('✅ Clean parsing complete\n');
                     }
                     else {
-                        this.warn('⚠️ Clean parsing failed');
+                        this.terminal.warn('⚠️ Clean parsing failed');
                     }
                 }
                 catch (error) {
-                    this.warn(`⚠️ Clean parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                    this.terminal.warn(`⚠️ Clean parsing error: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         }
@@ -163,7 +167,7 @@ export default class Watch extends Command {
             // If more files were added while parsing, queue another parse
             if (this.pendingParse) {
                 this.triggerParsing(ide, chatLogPath).catch((error) => {
-                    this.warn(`⚠️ Parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                    this.terminal.warn(`⚠️ Parsing error: ${error instanceof Error ? error.message : String(error)}`);
                 });
             }
         }

package/dist/config/environment.d.ts

@@ -17,7 +17,7 @@ type EnvironmentConfig = {
     clientId: string;
     cogitApiBaseUrl: string;
     issuerUrl: string;
-    llmGrpcEndpoint: string;
+    llmApiBaseUrl: string;
     memoraApiBaseUrl: string;
     mixpanelToken: string;
     scopes: string[];

package/dist/config/environment.js

@@ -15,7 +15,7 @@ export const ENV_CONFIG = {
         clientId: 'byterover-cli-client',
         cogitApiBaseUrl: 'https://dev-beta-cgit.byterover.dev/api/v1',
         issuerUrl: 'https://dev-beta-iam.byterover.dev/api/v1/oidc',
-        llmGrpcEndpoint: 'dev-beta-llm-grpc.byterover.dev',
+        llmApiBaseUrl: 'https://dev-beta-llm.byterover.dev',
         memoraApiBaseUrl: 'https://dev-beta-memora-retrieve.byterover.dev/api/v3',
         mixpanelToken: '258e1a2b3d44cc634ef28964771b1da0',
         scopes: ['read', 'write', 'debug'],
@@ -28,7 +28,7 @@ export const ENV_CONFIG = {
         clientId: 'byterover-cli',
         cogitApiBaseUrl: 'https://beta-cgit.byterover.dev/api/v1',
         issuerUrl: 'https://beta-iam.byterover.dev/api/v1/oidc',
-        llmGrpcEndpoint: 'beta-llm-grpc.byterover.dev',
+        llmApiBaseUrl: 'https://beta-llm.byterover.dev',
         memoraApiBaseUrl: 'https://beta-memora-retrieve.byterover.dev/api/v3',
         mixpanelToken: '4d1198b346d2d6ac75f2e77905cc65ac',
         scopes: ['read', 'write'],

package/dist/constants.d.ts

@@ -1,12 +1,11 @@
 export declare const BRV_DIR = ".brv";
+export declare const BLOBS_DIR = "blobs";
 export declare const PROJECT_CONFIG_FILE = "config.json";
 export declare const BRV_CONFIG_VERSION = "0.0.1";
+export declare const GLOBAL_CONFIG_DIR = "brv";
+export declare const GLOBAL_CONFIG_FILE = "config.json";
+export declare const GLOBAL_CONFIG_VERSION = "0.0.1";
 export declare const ACE_DIR = "ace";
-export declare const EXECUTOR_OUTPUTS_DIR = "executor-outputs";
-export declare const REFLECTIONS_DIR = "reflections";
-export declare const DELTAS_DIR = "deltas";
-export declare const BULLETS_DIR = "bullets";
-export declare const PLAYBOOK_FILE = "playbook.json";
 export declare const PROJECT = "byterover";
 export declare const CONTEXT_TREE_DIR = "context-tree";
 export declare const CONTEXT_FILE = "context.md";

package/dist/constants.js

@@ -1,13 +1,13 @@
 export const BRV_DIR = '.brv';
+export const BLOBS_DIR = 'blobs';
 export const PROJECT_CONFIG_FILE = 'config.json';
 export const BRV_CONFIG_VERSION = '0.0.1';
+// Global config constants (user-level, stored in XDG config directory)
+export const GLOBAL_CONFIG_DIR = 'brv';
+export const GLOBAL_CONFIG_FILE = 'config.json';
+export const GLOBAL_CONFIG_VERSION = '0.0.1';
 // ACE directory structure constants
 export const ACE_DIR = 'ace';
-export const EXECUTOR_OUTPUTS_DIR = 'executor-outputs';
-export const REFLECTIONS_DIR = 'reflections';
-export const DELTAS_DIR = 'deltas';
-export const BULLETS_DIR = 'bullets';
-export const PLAYBOOK_FILE = 'playbook.json';
 export const PROJECT = 'byterover';
 // Context Tree directory structure constants
 export const CONTEXT_TREE_DIR = 'context-tree';

package/dist/core/domain/cipher/errors/storage-error.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Error codes for key-based storage operations
+ */
+export declare enum StorageErrorCode {
+    /** Batch operation failed (partial or complete) */
+    BATCH_FAILED = "BATCH_FAILED",
+    /** Concurrent modification detected */
+    CONCURRENT_MODIFICATION = "CONCURRENT_MODIFICATION",
+    /** Delete operation failed */
+    DELETE_FAILED = "DELETE_FAILED",
+    /** Invalid key format (empty, contains invalid characters) */
+    KEY_INVALID = "KEY_INVALID",
+    /** Key does not exist in storage */
+    KEY_NOT_FOUND = "KEY_NOT_FOUND",
+    /** Lock acquisition timed out */
+    LOCK_TIMEOUT = "LOCK_TIMEOUT",
+    /** Storage not initialized */
+    NOT_INITIALIZED = "NOT_INITIALIZED",
+    /** Read operation failed */
+    READ_FAILED = "READ_FAILED",
+    /** Serialization/deserialization failed */
+    SERIALIZATION_FAILED = "SERIALIZATION_FAILED",
+    /** Storage backend unavailable */
+    STORAGE_UNAVAILABLE = "STORAGE_UNAVAILABLE",
+    /** Write operation failed */
+    WRITE_FAILED = "WRITE_FAILED"
+}
+/**
+ * Storage error class with factory methods for creating specific error instances.
+ * Follows the same pattern as BlobError for consistency.
+ */
+export declare class StorageError extends Error {
+    readonly code: StorageErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    readonly suggestion?: string | undefined;
+    constructor(message: string, code: StorageErrorCode, details?: Record<string, unknown> | undefined, suggestion?: string | undefined);
+    /**
+     * Create an error for batch operation failure.
+     */
+    static batchFailed(operationCount: number, cause?: Error): StorageError;
+    /**
+     * Create an error for concurrent modification.
+     */
+    static concurrentModification(key: readonly string[]): StorageError;
+    /**
+     * Create an error for delete failure.
+     */
+    static deleteFailed(key: readonly string[], cause?: Error): StorageError;
+    /**
+     * Check if an error is a specific type of StorageError.
+     */
+    static isCode(error: unknown, code: StorageErrorCode): boolean;
+    /**
+     * Check if an error is a StorageError.
+     */
+    static isStorageError(error: unknown): error is StorageError;
+    /**
+     * Create an error for invalid key format.
+     */
+    static keyInvalid(key: readonly string[], reason: string): StorageError;
+    /**
+     * Create an error for key not found.
+     */
+    static keyNotFound(key: readonly string[]): StorageError;
+    /**
+     * Create an error for lock timeout.
+     */
+    static lockTimeout(target: string, timeoutMs: number): StorageError;
+    /**
+     * Create an error for uninitialized storage.
+     */
+    static notInitialized(): StorageError;
+    /**
+     * Create an error for read failure.
+     */
+    static readFailed(key: readonly string[], cause?: Error): StorageError;
+    /**
+     * Create an error for serialization failure.
+     */
+    static serializationFailed(operation: 'deserialize' | 'serialize', cause?: Error): StorageError;
+    /**
+     * Create an error for unavailable storage backend.
+     */
+    static storageUnavailable(reason: string, cause?: Error): StorageError;
+    /**
+     * Create an error for write failure.
+     */
+    static writeFailed(key: readonly string[], cause?: Error): StorageError;
+}

package/dist/core/domain/cipher/errors/storage-error.js

@@ -0,0 +1,130 @@
+/**
+ * Error codes for key-based storage operations
+ */
+export var StorageErrorCode;
+(function (StorageErrorCode) {
+    /** Batch operation failed (partial or complete) */
+    StorageErrorCode["BATCH_FAILED"] = "BATCH_FAILED";
+    /** Concurrent modification detected */
+    StorageErrorCode["CONCURRENT_MODIFICATION"] = "CONCURRENT_MODIFICATION";
+    /** Delete operation failed */
+    StorageErrorCode["DELETE_FAILED"] = "DELETE_FAILED";
+    /** Invalid key format (empty, contains invalid characters) */
+    StorageErrorCode["KEY_INVALID"] = "KEY_INVALID";
+    /** Key does not exist in storage */
+    StorageErrorCode["KEY_NOT_FOUND"] = "KEY_NOT_FOUND";
+    /** Lock acquisition timed out */
+    StorageErrorCode["LOCK_TIMEOUT"] = "LOCK_TIMEOUT";
+    /** Storage not initialized */
+    StorageErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+    /** Read operation failed */
+    StorageErrorCode["READ_FAILED"] = "READ_FAILED";
+    /** Serialization/deserialization failed */
+    StorageErrorCode["SERIALIZATION_FAILED"] = "SERIALIZATION_FAILED";
+    /** Storage backend unavailable */
+    StorageErrorCode["STORAGE_UNAVAILABLE"] = "STORAGE_UNAVAILABLE";
+    /** Write operation failed */
+    StorageErrorCode["WRITE_FAILED"] = "WRITE_FAILED";
+})(StorageErrorCode || (StorageErrorCode = {}));
+/**
+ * Storage error class with factory methods for creating specific error instances.
+ * Follows the same pattern as BlobError for consistency.
+ */
+export class StorageError extends Error {
+    code;
+    details;
+    suggestion;
+    constructor(message, code, details, suggestion) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.suggestion = suggestion;
+        this.name = 'StorageError';
+    }
+    /**
+     * Create an error for batch operation failure.
+     */
+    static batchFailed(operationCount, cause) {
+        return new StorageError(`Batch operation failed with ${operationCount} operations`, StorageErrorCode.BATCH_FAILED, { cause: cause?.message, operationCount }, 'Check individual operation errors and retry the batch.');
+    }
+    /**
+     * Create an error for concurrent modification.
+     */
+    static concurrentModification(key) {
+        const keyPath = key.join(':');
+        return new StorageError(`Concurrent modification detected for: ${keyPath}`, StorageErrorCode.CONCURRENT_MODIFICATION, { key: keyPath }, 'The data was modified by another operation. Retry with fresh data.');
+    }
+    /**
+     * Create an error for delete failure.
+     */
+    static deleteFailed(key, cause) {
+        const keyPath = key.join(':');
+        return new StorageError(`Delete failed for key: ${keyPath}`, StorageErrorCode.DELETE_FAILED, { cause: cause?.message, key: keyPath }, 'Check storage permissions.');
+    }
+    /**
+     * Check if an error is a specific type of StorageError.
+     */
+    static isCode(error, code) {
+        return error instanceof StorageError && error.code === code;
+    }
+    /**
+     * Check if an error is a StorageError.
+     */
+    static isStorageError(error) {
+        return error instanceof StorageError;
+    }
+    /**
+     * Create an error for invalid key format.
+     */
+    static keyInvalid(key, reason) {
+        const keyPath = key.join(':');
+        return new StorageError(`Invalid key: ${keyPath} - ${reason}`, StorageErrorCode.KEY_INVALID, { key: keyPath, reason }, 'Keys must be non-empty arrays of strings without colon characters.');
+    }
+    /**
+     * Create an error for key not found.
+     */
+    static keyNotFound(key) {
+        const keyPath = key.join(':');
+        return new StorageError(`Key not found: ${keyPath}`, StorageErrorCode.KEY_NOT_FOUND, { key: keyPath }, 'Check if the key exists using exists() before accessing.');
+    }
+    /**
+     * Create an error for lock timeout.
+     */
+    static lockTimeout(target, timeoutMs) {
+        return new StorageError(`Lock acquisition timed out for: ${target} after ${timeoutMs}ms`, StorageErrorCode.LOCK_TIMEOUT, { target, timeoutMs }, 'The resource may be held by another operation. Try again later.');
+    }
+    /**
+     * Create an error for uninitialized storage.
+     */
+    static notInitialized() {
+        return new StorageError('Storage not initialized', StorageErrorCode.NOT_INITIALIZED, undefined, 'Call initialize() before performing any storage operations.');
+    }
+    /**
+     * Create an error for read failure.
+     */
+    static readFailed(key, cause) {
+        const keyPath = key.join(':');
+        return new StorageError(`Read failed for key: ${keyPath}`, StorageErrorCode.READ_FAILED, { cause: cause?.message, key: keyPath }, 'Check if the storage is accessible and the data is not corrupted.');
+    }
+    /**
+     * Create an error for serialization failure.
+     */
+    static serializationFailed(operation, cause) {
+        return new StorageError(`Failed to ${operation} data`, StorageErrorCode.SERIALIZATION_FAILED, { cause: cause?.message, operation }, operation === 'serialize'
+            ? 'Ensure the data is JSON-serializable (no circular references, BigInt, etc.).'
+            : 'The stored data may be corrupted or in an unexpected format.');
+    }
+    /**
+     * Create an error for unavailable storage backend.
+     */
+    static storageUnavailable(reason, cause) {
+        return new StorageError(`Storage unavailable: ${reason}`, StorageErrorCode.STORAGE_UNAVAILABLE, { cause: cause?.message, reason }, 'Check database connection and file system access.');
+    }
+    /**
+     * Create an error for write failure.
+     */
+    static writeFailed(key, cause) {
+        const keyPath = key.join(':');
+        return new StorageError(`Write failed for key: ${keyPath}`, StorageErrorCode.WRITE_FAILED, { cause: cause?.message, key: keyPath }, 'Check storage permissions and available space.');
+    }
+}

package/dist/core/domain/cipher/queue/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Queue/Execution domain types for the agent storage system.
+ *
+ * These types represent the core domain entities for:
+ * - Execution queue (curate/query jobs)
+ * - Tool call tracking
+ * - Consumer lock management
+ */
+export type ExecutionType = 'curate' | 'query';
+export type ExecutionStatus = 'completed' | 'failed' | 'queued' | 'running';
+/**
+ * Represents a single execution job in the queue.
+ */
+export interface Execution {
+    completedAt?: number;
+    createdAt: number;
+    error?: string;
+    id: string;
+    input: string;
+    pid?: number;
+    result?: string;
+    startedAt?: number;
+    status: ExecutionStatus;
+    type: ExecutionType;
+    updatedAt: number;
+}
+export type ToolCallStatus = 'completed' | 'failed' | 'running';
+/**
+ * Represents a tool call made during an execution.
+ */
+export interface ToolCall {
+    args: string;
+    charsCount?: number;
+    completedAt?: number;
+    description?: string;
+    durationMs?: number;
+    executionId: string;
+    id: string;
+    linesCount?: number;
+    name: string;
+    result?: string;
+    resultSummary?: string;
+    startedAt: number;
+    status: ToolCallStatus;
+}
+/**
+ * Input for creating a new tool call record.
+ */
+export interface ToolCallInfo {
+    args: Record<string, unknown>;
+    description?: string;
+    name: string;
+}
+/**
+ * Options for updating an existing tool call.
+ */
+export interface ToolCallUpdateOptions {
+    charsCount?: number;
+    linesCount?: number;
+    result?: string;
+    resultSummary?: string;
+}
+/**
+ * Represents an active consumer lock.
+ */
+export interface ConsumerLock {
+    id: string;
+    lastHeartbeat: number;
+    pid: number;
+    startedAt: number;
+}

package/dist/core/domain/cipher/queue/types.js

@@ -0,0 +1,9 @@
+/**
+ * Queue/Execution domain types for the agent storage system.
+ *
+ * These types represent the core domain entities for:
+ * - Execution queue (curate/query jobs)
+ * - Tool call tracking
+ * - Consumer lock management
+ */
+export {};