byterover-cli 0.2.1 → 0.3.0

package/dist/infra/context-tree/file-context-tree-service.js

@@ -0,0 +1,46 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CONTEXT_TREE_DOMAINS } from '../../config/context-tree-domains.js';
+import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR } from '../../constants.js';
+/**
+ * File-based implementation of IContextTreeService.
+ * Provides operations for managing the context tree structure.
+ */
+export class FileContextTreeService {
+    config;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async exists(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+        try {
+            // Check if context tree directory exists
+            const { access } = await import('node:fs/promises');
+            await access(contextTreeDir);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async initialize(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const brvDir = join(baseDir, BRV_DIR);
+        const contextTreeDir = join(brvDir, CONTEXT_TREE_DIR);
+        // Create .brv/context-tree/ directory
+        await mkdir(contextTreeDir, { recursive: true });
+        // Create domain folders and context.md files in parallel
+        await Promise.all(CONTEXT_TREE_DOMAINS.map(async (domain) => {
+            const domainPath = join(contextTreeDir, domain.name);
+            await mkdir(domainPath, { recursive: true });
+            // Write context.md with domain description
+            const contextMdPath = join(domainPath, CONTEXT_FILE);
+            const contextContent = `# ${domain.name.replaceAll('_', ' ').replaceAll(/\b\w/g, (c) => c.toUpperCase())}\n\n${domain.description}\n`;
+            await writeFile(contextMdPath, contextContent, 'utf8');
+        }));
+        // Note: index.json is no longer created as it's not actively used
+        // Context tree uses filesystem-based discovery instead
+        return contextTreeDir;
+    }
+}

package/dist/infra/context-tree/file-context-tree-snapshot-service.d.ts

@@ -0,0 +1,34 @@
+import type { IContextTreeSnapshotService } from '../../core/interfaces/i-context-tree-snapshot-service.js';
+import { ContextTreeChanges, FileState } from '../../core/domain/entities/context-tree-snapshot.js';
+export type ContextTreeSnapshotServiceConfig = {
+    baseDirectory?: string;
+};
+/**
+ * File-based implementation of IContextTreeSnapshotService.
+ * Tracks context tree changes using content hashing.
+ */
+export declare class FileContextTreeSnapshotService implements IContextTreeSnapshotService {
+    private readonly config;
+    constructor(config?: ContextTreeSnapshotServiceConfig);
+    getChanges(directory?: string): Promise<ContextTreeChanges>;
+    getCurrentState(directory?: string): Promise<Map<string, FileState>>;
+    hasSnapshot(directory?: string): Promise<boolean>;
+    initEmptySnapshot(directory?: string): Promise<void>;
+    saveSnapshot(directory?: string): Promise<void>;
+    /**
+     * Computes SHA-256 hash of file content.
+     */
+    private computeHash;
+    /**
+     * Loads snapshot from file.
+     */
+    private loadSnapshot;
+    /**
+     * Processes a single file and adds it to the files map.
+     */
+    private processFile;
+    /**
+     * Recursively scans directory for files, excluding snapshot file.
+     */
+    private scanDirectory;
+}

package/dist/infra/context-tree/file-context-tree-snapshot-service.js

@@ -0,0 +1,117 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { BRV_DIR, CONTEXT_FILE, CONTEXT_TREE_DIR, SNAPSHOT_FILE } from '../../constants.js';
+import { ContextTreeSnapshot, } from '../../core/domain/entities/context-tree-snapshot.js';
+/**
+ * File-based implementation of IContextTreeSnapshotService.
+ * Tracks context tree changes using content hashing.
+ */
+export class FileContextTreeSnapshotService {
+    config;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async getChanges(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+        const snapshot = await this.loadSnapshot(contextTreeDir);
+        if (!snapshot) {
+            // No snapshot means everything is "new" but we return empty for clean status
+            return { added: [], deleted: [], modified: [] };
+        }
+        const currentState = await this.getCurrentState(directory);
+        return snapshot.compare(currentState);
+    }
+    async getCurrentState(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+        const files = new Map();
+        try {
+            await this.scanDirectory(contextTreeDir, contextTreeDir, files);
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+            return files;
+        }
+        return files;
+    }
+    async hasSnapshot(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const snapshotPath = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR, SNAPSHOT_FILE);
+        try {
+            await stat(snapshotPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async initEmptySnapshot(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+        const snapshotPath = join(contextTreeDir, SNAPSHOT_FILE);
+        const emptySnapshot = ContextTreeSnapshot.create(new Map());
+        await writeFile(snapshotPath, JSON.stringify(emptySnapshot.toJson(), null, 2), 'utf8');
+    }
+    async saveSnapshot(directory) {
+        const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
+        const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+        const snapshotPath = join(contextTreeDir, SNAPSHOT_FILE);
+        const currentState = await this.getCurrentState(directory);
+        const snapshot = ContextTreeSnapshot.create(currentState);
+        await writeFile(snapshotPath, JSON.stringify(snapshot.toJson(), null, 2), 'utf8');
+    }
+    /**
+     * Computes SHA-256 hash of file content.
+     */
+    computeHash(content) {
+        return createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Loads snapshot from file.
+     */
+    async loadSnapshot(contextTreeDir) {
+        const snapshotPath = join(contextTreeDir, SNAPSHOT_FILE);
+        try {
+            const content = await readFile(snapshotPath, 'utf8');
+            const json = JSON.parse(content);
+            return ContextTreeSnapshot.fromJson(json) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Processes a single file and adds it to the files map.
+     */
+    async processFile(fullPath, rootDir, files) {
+        const relativePath = relative(rootDir, fullPath);
+        const [content, fileStat] = await Promise.all([readFile(fullPath), stat(fullPath)]);
+        files.set(relativePath, {
+            hash: this.computeHash(content),
+            size: fileStat.size,
+        });
+    }
+    /**
+     * Recursively scans directory for files, excluding snapshot file.
+     */
+    async scanDirectory(currentDir, rootDir, files) {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        const tasks = [];
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            // Skip snapshot file
+            if (entry.name === SNAPSHOT_FILE) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                tasks.push(this.scanDirectory(fullPath, rootDir, files));
+            }
+            else if (entry.isFile() && entry.name === CONTEXT_FILE) {
+                tasks.push(this.processFile(fullPath, rootDir, files));
+            }
+        }
+        await Promise.all(tasks);
+    }
+}

package/dist/infra/context-tree/file-context-tree-writer-service.d.ts

@@ -0,0 +1,22 @@
+import type { IContextTreeSnapshotService } from '../../core/interfaces/i-context-tree-snapshot-service.js';
+import type { IContextTreeWriterService, SyncParams, SyncResult } from '../../core/interfaces/i-context-tree-writer-service.js';
+export type ContextTreeWriterServiceConfig = {
+    baseDirectory?: string;
+};
+export type ContextTreeWriterServiceDependencies = {
+    snapshotService: IContextTreeSnapshotService;
+};
+/**
+ * File-based implementation of IContextTreeWriterService.
+ * Synchronizes context tree files based on CoGit snapshot data.
+ */
+export declare class FileContextTreeWriterService implements IContextTreeWriterService {
+    private readonly config;
+    private readonly snapshotService;
+    constructor(dependencies: ContextTreeWriterServiceDependencies, config?: ContextTreeWriterServiceConfig);
+    sync(params: SyncParams): Promise<SyncResult>;
+    /**
+     * Normalizes a file path by removing leading slashes.
+     */
+    private normalizePath;
+}

package/dist/infra/context-tree/file-context-tree-writer-service.js

@@ -0,0 +1,61 @@
+/* eslint-disable no-await-in-loop */
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
+/**
+ * File-based implementation of IContextTreeWriterService.
+ * Synchronizes context tree files based on CoGit snapshot data.
+ */
+export class FileContextTreeWriterService {
+    config;
+    snapshotService;
+    constructor(dependencies, config = {}) {
+        this.snapshotService = dependencies.snapshotService;
+        this.config = config;
+    }
+    async sync(params) {
+        const baseDir = params.directory ?? this.config.baseDirectory ?? process.cwd();
+        const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+        // Get current local state
+        const localState = await this.snapshotService.getCurrentState(params.directory);
+        // Build map of remote files (normalize paths - remove leading /)
+        const remoteFiles = new Map(params.files.map((file) => [this.normalizePath(file.path), file]));
+        const added = [];
+        const edited = [];
+        const deleted = [];
+        // Process remote files: add or edit
+        for (const [remoteRelativePath, remoteFile] of remoteFiles) {
+            const fullPath = join(contextTreeDir, remoteRelativePath);
+            const decodedContent = remoteFile.decodeContent();
+            if (localState.has(remoteRelativePath)) {
+                // File exists locally - check if content differs
+                const localContent = await readFile(fullPath, 'utf8');
+                if (localContent !== decodedContent) {
+                    await writeFile(fullPath, decodedContent, 'utf8');
+                    edited.push(remoteRelativePath);
+                }
+            }
+            else {
+                // New file - create parent directories and write
+                await mkdir(dirname(fullPath), { recursive: true });
+                await writeFile(fullPath, decodedContent, 'utf8');
+                added.push(remoteRelativePath);
+            }
+        }
+        // Process deletions: local files not in remote
+        for (const localPath of localState.keys()) {
+            if (!remoteFiles.has(localPath)) {
+                const fullPath = join(contextTreeDir, localPath);
+                await unlink(fullPath);
+                deleted.push(localPath);
+            }
+        }
+        return { added, deleted, edited };
+    }
+    /**
+     * Normalizes a file path by removing leading slashes.
+     */
+    normalizePath(path) {
+        return path.replace(/^\/+/, '');
+    }
+}

package/dist/infra/memory/http-memory-retrieval-service.js

@@ -1,5 +1,6 @@
 import { Memory } from '../../core/domain/entities/memory.js';
 import { RetrieveResult } from '../../core/domain/entities/retrieve-result.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
 import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
 /**
  * HTTP implementation of IMemoryRetrievalService for ByteRover Memora service.
@@ -24,7 +25,7 @@ export class HttpMemoryRetrievalService {
             return this.mapToRetrieveResult(response);
         }
         catch (error) {
-            throw new Error(`Failed to retrieve memories: ${error.message}`);
+            throw new Error(`Failed to retrieve memories: ${getErrorMessage(error)}`);
         }
     }
     buildQueryParams(params) {

package/dist/infra/memory/http-memory-storage-service.js

@@ -2,6 +2,7 @@
 import axios from 'axios';
 import { PresignedUrl } from '../../core/domain/entities/presigned-url.js';
 import { PresignedUrlsResponse } from '../../core/domain/entities/presigned-urls-response.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
 import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
 /**
  * HTTP implementation of IMemoryStorageService for ByteRover CoGit service.
@@ -27,7 +28,7 @@ export class HttpMemoryStorageService {
             });
         }
         catch (error) {
-            throw new Error(`Failed to confirm upload: ${error.message}`);
+            throw new Error(`Failed to confirm upload: ${getErrorMessage(error)}`);
         }
     }
     async getPresignedUrls(params) {
@@ -45,7 +46,7 @@ export class HttpMemoryStorageService {
             return new PresignedUrlsResponse(presignedUrls, response.data.request_id);
         }
         catch (error) {
-            throw new Error(`Failed to get presigned URLs: ${error.message}`);
+            throw new Error(`Failed to get presigned URLs: ${getErrorMessage(error)}`);
         }
     }
     async uploadFile(uploadUrl, content) {
@@ -58,7 +59,7 @@ export class HttpMemoryStorageService {
             });
         }
         catch (error) {
-            throw new Error(`Failed to upload file: ${error.message}`);
+            throw new Error(`Failed to upload file: ${getErrorMessage(error)}`);
         }
     }
     mapToPresignedUrls(presignedUrlData) {

package/dist/infra/parsers/clean/clean-claude-service.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Claude Clean Service
+ * Transforms Claude raw parsed data to clean normalized format
+ * Consolidates agent sessions and normalizes messages
+ */
+import type { CleanSession } from '../../../core/domain/entities/parser.js';
+import { Agent } from '../../../core/domain/entities/agent.js';
+import { ICleanParserService } from '../../../core/interfaces/parser/i-clean-parser-service.js';
+/**
+ * Claude Clean Service
+ * Transforms Claude raw parsed sessions to clean normalized format
+ */
+export declare class ClaudeCleanService implements ICleanParserService {
+    private ide;
+    /**
+     * Initialize Claude Clean Service
+     *
+     * @param ide - The IDE type (Claude Code)
+     */
+    constructor(ide: Agent);
+    /**
+     * Parse and transform raw Claude sessions to clean normalized format
+     *
+     * Reads raw sessions organized by workspace, consolidates agent sessions into main
+     * conversations, and normalizes message format. Returns sessions in-memory without file writing.
+     *
+     * @param rawDir - Path to directory containing raw Claude session files organized by workspace
+     * @returns Promise resolving to array of clean normalized sessions
+     */
+    parse(rawDir: string): Promise<readonly CleanSession[]>;
+    /**
+     * Calculate string similarity score using word overlap method
+     *
+     * Computes similarity by comparing words with length > 3 characters.
+     * Returns fraction of matching words relative to max length.
+     *
+     * @param str1 - First string to compare
+     * @param str2 - Second string to compare
+     * @returns Similarity score between 0 (no match) and 1 (perfect match)
+     */
+    private calculateSimilarity;
+    /**
+     * Consolidate agent session data into main conversation
+     *
+     * When main conversation contains Task subagent invocation, flattens the agent
+     * session messages into the main message stream. Two-pass algorithm: first identify
+     * Task invocations with matching agent sessions, then insert agent messages.
+     *
+     * @param mainSession - Main Claude conversation session to consolidate into
+     * @param agentSessions - Map of agent sessions keyed by agent session ID
+     * @returns Promise resolving to consolidated session with agent messages merged
+     */
+    private consolidateAgentSessions;
+    /**
+     * Find best matching agent session for a task description and timestamp
+     *
+     * Locates matching agent session using similarity scoring and timestamp proximity.
+     * Considers both task description similarity and temporal closeness (within 5 seconds).
+     *
+     * @param description - Task description from Task tool_use invocation
+     * @param messageTimestamp - Timestamp of message containing Task invocation
+     * @param agentSessions - Map of available agent sessions
+     * @returns Matching agent session or null if no good match found
+     */
+    private findMatchingAgentSession;
+    /**
+     * Flatten messages with agent sessions inserted after Task invocations
+     *
+     * Inserts agent session messages into message stream after Task tool_use invocations
+     * that have matching agent sessions. Preserves message order.
+     *
+     * @param messages - Array of raw session messages
+     * @param taskToolUseIds - Set of Task tool_use IDs that have matching agent sessions
+     * @param agentSessions - Map of available agent sessions
+     * @returns Flattened message array with agent messages interleaved
+     */
+    private flattenMessagesWithAgentSessions;
+    /**
+     * Identify Task tool_use IDs that have matching agent sessions
+     *
+     * Scans messages for Task tool_use invocations and identifies which ones
+     * have corresponding agent sessions that can be consolidated.
+     *
+     * @param messages - Array of session messages
+     * @param agentSessions - Map of available agent sessions
+     * @returns Set of tool_use IDs that have matching agent sessions
+     */
+    private identifyTaskToolIds;
+    /**
+     * Load and organize sessions from workspace directory
+     *
+     * Reads JSON files from workspace directory and organizes them into main sessions
+     * and agent sessions based on filename prefix ('agent-' for agent sessions).
+     *
+     * @param workspacePath - Path to workspace directory containing session files
+     * @param jsonFiles - Array of JSON filenames to load
+     * @returns Promise resolving to object with separated agentSessions and allSessions maps
+     */
+    private loadSessions;
+    /**
+     * Process main sessions and return normalized outputs
+     *
+     * Consolidates agent sessions and normalizes each session.
+     * Returns normalized sessions in-memory without writing to disk.
+     *
+     * @param allSessions - Map of main sessions to process
+     * @param agentSessions - Map of available agent sessions for consolidation
+     * @returns Promise resolving to array of clean normalized sessions
+     */
+    private processMainSessions;
+}