byterover-cli 0.2.1 → 0.3.0

package/dist/commands/pull.js

@@ -0,0 +1,115 @@
+import { Command, Flags, ux } from '@oclif/core';
+import { getCurrentConfig } from '../config/environment.js';
+import { DEFAULT_BRANCH } from '../constants.js';
+import { ExitCode, ExitError, exitWithCode } from '../infra/cipher/exit-codes.js';
+import { WorkspaceNotInitializedError } from '../infra/cipher/validation/workspace-validator.js';
+import { HttpCogitPullService } from '../infra/cogit/http-cogit-pull-service.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { FileContextTreeSnapshotService } from '../infra/context-tree/file-context-tree-snapshot-service.js';
+import { FileContextTreeWriterService } from '../infra/context-tree/file-context-tree-writer-service.js';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+export default class Pull extends Command {
+    static description = 'Pull context tree from ByteRover memory storage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --branch develop',
+        '<%= config.bin %> <%= command.id %> -b feature-auth',
+    ];
+    static flags = {
+        branch: Flags.string({
+            char: 'b',
+            default: DEFAULT_BRANCH,
+            description: 'ByteRover branch name (not Git branch)',
+        }),
+    };
+    async catch(error) {
+        if (error instanceof ExitError) {
+            return;
+        }
+        if (error.oclif?.exit !== undefined) {
+            return;
+        }
+        throw error;
+    }
+    async checkLocalChanges(contextTreeSnapshotService) {
+        const changes = await contextTreeSnapshotService.getChanges();
+        return changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+    }
+    async checkProjectInit(projectConfigStore) {
+        const projectConfig = await projectConfigStore.read();
+        if (projectConfig === undefined) {
+            throw new WorkspaceNotInitializedError('Project not initialized. Please run "brv init" to select your team and workspace.', '.brv');
+        }
+        return projectConfig;
+    }
+    createServices() {
+        const envConfig = getCurrentConfig();
+        const tokenStore = new KeychainTokenStore();
+        const trackingService = new MixpanelTrackingService(tokenStore);
+        const contextTreeSnapshotService = new FileContextTreeSnapshotService();
+        return {
+            cogitPullService: new HttpCogitPullService({
+                apiBaseUrl: envConfig.cogitApiBaseUrl,
+            }),
+            contextTreeSnapshotService,
+            contextTreeWriterService: new FileContextTreeWriterService({ snapshotService: contextTreeSnapshotService }),
+            projectConfigStore: new ProjectConfigStore(),
+            tokenStore,
+            trackingService,
+        };
+    }
+    async run() {
+        const { flags } = await this.parse(Pull);
+        try {
+            const { cogitPullService, contextTreeSnapshotService, contextTreeWriterService, projectConfigStore, tokenStore, trackingService, } = this.createServices();
+            await trackingService.track('mem:pull');
+            const token = await this.validateAuth(tokenStore);
+            const projectConfig = await this.checkProjectInit(projectConfigStore);
+            // Check for local changes
+            ux.action.start('Checking for local Context Tree changes');
+            const hasLocalChanges = await this.checkLocalChanges(contextTreeSnapshotService);
+            ux.action.stop();
+            if (hasLocalChanges) {
+                exitWithCode(ExitCode.VALIDATION_ERROR, 'You have local changes that have not been pushed. Run "brv push" first.');
+            }
+            // Pull from CoGit
+            this.log('Pulling from ByteRover...');
+            const snapshot = await cogitPullService.pull({
+                accessToken: token.accessToken,
+                branch: flags.branch,
+                sessionKey: token.sessionKey,
+                spaceId: projectConfig.spaceId,
+                teamId: projectConfig.teamId,
+            });
+            // Sync files to local context tree
+            ux.action.start('Syncing context files');
+            const syncResult = await contextTreeWriterService.sync({ files: snapshot.files });
+            ux.action.stop();
+            // Update snapshot ONLY after successful sync
+            await contextTreeSnapshotService.saveSnapshot();
+            // Success message
+            this.log('\n✓ Successfully pulled context tree from ByteRover memory storage!');
+            this.log(`  Branch: ${flags.branch}`);
+            this.log(`  Commit: ${snapshot.commitSha.slice(0, 7)}`);
+            this.log(`  Added: ${syncResult.added.length}, Edited: ${syncResult.edited.length}, Deleted: ${syncResult.deleted.length}`);
+        }
+        catch (error) {
+            if (error instanceof WorkspaceNotInitializedError) {
+                exitWithCode(ExitCode.VALIDATION_ERROR, 'Project not initialized. Please run "brv init" to select your team and workspace.');
+            }
+            const message = error instanceof Error ? error.message : 'Pull failed';
+            exitWithCode(ExitCode.RUNTIME_ERROR, `Failed to pull: ${message}`);
+        }
+    }
+    async validateAuth(tokenStore) {
+        const token = await tokenStore.load();
+        if (token === undefined) {
+            this.error('Not authenticated. Run "brv login" first.');
+        }
+        if (!token.isValid()) {
+            this.error('Authentication token expired. Run "brv login" again.');
+        }
+        return token;
+    }
+}

package/dist/commands/push.d.ts

@@ -1,12 +1,11 @@
 import { Command } from '@oclif/core';
 import type { AuthToken } from '../core/domain/entities/auth-token.js';
 import type { BrvConfig } from '../core/domain/entities/brv-config.js';
-import type { PresignedUrl } from '../core/domain/entities/presigned-url.js';
-import type { PresignedUrlsResponse } from '../core/domain/entities/presigned-urls-response.js';
-import type { IMemoryStorageService } from '../core/interfaces/i-memory-storage-service.js';
-import type { IPlaybookStore } from '../core/interfaces/i-playbook-store.js';
+import type { ICogitPushService } from '../core/interfaces/i-cogit-push-service.js';
+import type { IContextFileReader } from '../core/interfaces/i-context-file-reader.js';
 import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
 import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import { IContextTreeSnapshotService } from '../core/interfaces/i-context-tree-snapshot-service.js';
 import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
 export default class Push extends Command {
     static description: string;
@@ -15,21 +14,22 @@ export default class Push extends Command {
         branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    protected buildSpaceUrl(webAppUrl: string, teamName: string, spaceName: string): string;
+    catch(error: Error & {
+        oclif?: {
+            exit: number;
+        };
+    }): Promise<void>;
     protected checkProjectInit(projectConfigStore: IProjectConfigStore): Promise<BrvConfig>;
-    protected cleanUpLocalFiles(playbookStore: IPlaybookStore): Promise<void>;
-    protected confirmPush(projectConfig: BrvConfig, branch: string, fileCount: number): Promise<boolean>;
-    protected confirmUpload(memoryService: IMemoryStorageService, token: AuthToken, projectConfig: BrvConfig, requestId: string): Promise<void>;
+    protected confirmPush(projectConfig: BrvConfig, branch: string): Promise<boolean>;
     protected createServices(): {
-        memoryService: IMemoryStorageService;
-        playbookStore: IPlaybookStore;
+        cogitPushService: ICogitPushService;
+        contextFileReader: IContextFileReader;
+        contextTreeSnapshotService: IContextTreeSnapshotService;
         projectConfigStore: IProjectConfigStore;
         tokenStore: ITokenStore;
         trackingService: ITrackingService;
     };
-    protected getPresignedUrls(memoryService: IMemoryStorageService, token: AuthToken, projectConfig: BrvConfig): Promise<PresignedUrlsResponse>;
-    protected loadPlaybookContent(playbookStore: IPlaybookStore): Promise<string>;
     run(): Promise<void>;
-    protected uploadFiles(memoryService: IMemoryStorageService, presignedUrls: ReadonlyArray<PresignedUrl>, playbookContent: string): Promise<void>;
     protected validateAuth(tokenStore: ITokenStore): Promise<AuthToken>;
-    protected verifyPlaybookExists(playbookStore: IPlaybookStore): Promise<void>;
 }

package/dist/commands/push.js

@@ -1,16 +1,18 @@
 import { confirm } from '@inquirer/prompts';
 import { Command, Flags, ux } from '@oclif/core';
-import { join } from 'node:path';
 import { getCurrentConfig } from '../config/environment.js';
-import { ACE_DIR, BRV_DIR, BULLETS_DIR, DEFAULT_BRANCH, DELTAS_DIR, EXECUTOR_OUTPUTS_DIR, PLAYBOOK_FILE, REFLECTIONS_DIR, } from '../constants.js';
-import { FilePlaybookStore } from '../infra/ace/file-playbook-store.js';
+import { DEFAULT_BRANCH } from '../constants.js';
+import { ExitCode, ExitError, exitWithCode } from '../infra/cipher/exit-codes.js';
+import { WorkspaceNotInitializedError } from '../infra/cipher/validation/workspace-validator.js';
+import { mapToPushContexts } from '../infra/cogit/context-tree-to-push-context-mapper.js';
+import { HttpCogitPushService } from '../infra/cogit/http-cogit-push-service.js';
 import { ProjectConfigStore } from '../infra/config/file-config-store.js';
-import { HttpMemoryStorageService } from '../infra/memory/http-memory-storage-service.js';
+import { FileContextFileReader } from '../infra/context-tree/file-context-file-reader.js';
+import { FileContextTreeSnapshotService } from '../infra/context-tree/file-context-tree-snapshot-service.js';
 import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
 import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
-import { clearDirectory } from '../utils/file-helpers.js';
 export default class Push extends Command {
-    static description = 'Push playbook to ByteRover memory storage and clean up local ACE files';
+    static description = 'Push context tree to ByteRover memory storage';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --branch develop',
@@ -29,138 +31,122 @@ export default class Push extends Command {
             description: 'Skip confirmation prompt',
         }),
     };
+    buildSpaceUrl(webAppUrl, teamName, spaceName) {
+        return `${webAppUrl}/${teamName}/${spaceName}`;
+    }
+    // Override catch to prevent oclif from logging errors that were already displayed
+    async catch(error) {
+        // Check if error is ExitError (message already displayed by exitWithCode)
+        if (error instanceof ExitError) {
+            return;
+        }
+        // Backwards compatibility: also check oclif.exit property
+        if (error.oclif?.exit !== undefined) {
+            // Error already displayed by exitWithCode, silently exit
+            return;
+        }
+        // For other errors, re-throw to let oclif handle them
+        throw error;
+    }
     async checkProjectInit(projectConfigStore) {
         const projectConfig = await projectConfigStore.read();
         if (projectConfig === undefined) {
-            this.error('Project not initialized. Run "brv init" first.');
+            throw new WorkspaceNotInitializedError('Project not initialized. Please run "brv init" to select your team and workspace.', '.brv');
         }
         return projectConfig;
     }
-    async cleanUpLocalFiles(playbookStore) {
-        this.log('\nCleaning up local files...');
-        // Clear playbook content and bullet files
-        ux.action.start('  Clearing playbook and bullet files');
-        await playbookStore.clear();
-        ux.action.stop('✓');
-        // Clean executor outputs
-        const baseDir = process.cwd();
-        const aceDir = join(baseDir, BRV_DIR, ACE_DIR);
-        const executorOutputsDir = join(aceDir, EXECUTOR_OUTPUTS_DIR);
-        const reflectionsDir = join(aceDir, REFLECTIONS_DIR);
-        const deltasDir = join(aceDir, DELTAS_DIR);
-        ux.action.start('  Cleaning executor outputs');
-        const executorCount = await clearDirectory(executorOutputsDir);
-        ux.action.stop(`✓ (${executorCount} files removed)`);
-        // Clean reflections
-        ux.action.start('  Cleaning reflections');
-        const reflectionCount = await clearDirectory(reflectionsDir);
-        ux.action.stop(`✓ (${reflectionCount} files removed)`);
-        // Clean deltas
-        ux.action.start('  Cleaning deltas');
-        const deltaCount = await clearDirectory(deltasDir);
-        ux.action.stop(`✓ (${deltaCount} files removed)`);
-    }
-    async confirmPush(projectConfig, branch, fileCount) {
+    async confirmPush(projectConfig, branch) {
         this.log('\nYou are about to push to ByteRover memory storage:');
         this.log(`  Space: ${projectConfig.spaceName}`);
         this.log(`  Branch: ${branch}`);
-        this.log(`  Files to upload: ${fileCount}`);
-        this.log('\nAfter successful push, these local files will be cleaned up:');
-        this.log('  - Playbook content');
-        this.log(`  - Bullet files (${BRV_DIR}/${ACE_DIR}/${BULLETS_DIR}/)`);
-        this.log(`  - Executor outputs (${BRV_DIR}/${ACE_DIR}/${EXECUTOR_OUTPUTS_DIR}/)`);
-        this.log(`  - Reflections (${BRV_DIR}/${ACE_DIR}/${REFLECTIONS_DIR}/)`);
-        this.log(`  - Deltas (${BRV_DIR}/${ACE_DIR}/${DELTAS_DIR}/)`);
         return confirm({
             default: false,
-            message: 'Push to ByteRover and clean up local files?',
+            message: 'Push to ByteRover?',
         });
     }
-    async confirmUpload(memoryService, token, projectConfig, requestId) {
-        ux.action.start('Confirming upload');
-        await memoryService.confirmUpload({
-            accessToken: token.accessToken,
-            requestId,
-            sessionKey: token.sessionKey,
-            spaceId: projectConfig.spaceId,
-            teamId: projectConfig.teamId,
-        });
-        ux.action.stop('✓');
-    }
     createServices() {
         const envConfig = getCurrentConfig();
         const tokenStore = new KeychainTokenStore();
         const trackingService = new MixpanelTrackingService(tokenStore);
         return {
-            memoryService: new HttpMemoryStorageService({
+            cogitPushService: new HttpCogitPushService({
                 apiBaseUrl: envConfig.cogitApiBaseUrl,
             }),
-            playbookStore: new FilePlaybookStore(),
+            contextFileReader: new FileContextFileReader(),
+            contextTreeSnapshotService: new FileContextTreeSnapshotService(),
             projectConfigStore: new ProjectConfigStore(),
             tokenStore,
             trackingService,
         };
     }
-    async getPresignedUrls(memoryService, token, projectConfig) {
-        const { flags } = await this.parse(Push);
-        ux.action.start('Requesting upload URLs');
-        const response = await memoryService.getPresignedUrls({
-            accessToken: token.accessToken,
-            branch: flags.branch,
-            fileNames: [`${PLAYBOOK_FILE}`],
-            sessionKey: token.sessionKey,
-            spaceId: projectConfig.spaceId,
-            teamId: projectConfig.teamId,
-        });
-        ux.action.stop();
-        return response;
-    }
-    async loadPlaybookContent(playbookStore) {
-        ux.action.start('Loading playbook');
-        const playbook = await playbookStore.load();
-        if (playbook === undefined) {
-            this.error('Failed to load playbook');
-        }
-        const playbookContent = playbook.dumps();
-        ux.action.stop();
-        return playbookContent;
-    }
     async run() {
         const { flags } = await this.parse(Push);
         try {
-            const { memoryService, playbookStore, projectConfigStore, tokenStore, trackingService } = this.createServices();
+            const { cogitPushService, contextFileReader, contextTreeSnapshotService, projectConfigStore, tokenStore, trackingService, } = this.createServices();
             await trackingService.track('mem:push');
             const token = await this.validateAuth(tokenStore);
             const projectConfig = await this.checkProjectInit(projectConfigStore);
-            await this.verifyPlaybookExists(playbookStore);
+            // Check for changes
+            ux.action.start('Checking for Context Tree changes');
+            const contextTreeChanges = await contextTreeSnapshotService.getChanges();
+            ux.action.stop();
+            if (contextTreeChanges.added.length === 0 &&
+                contextTreeChanges.modified.length === 0 &&
+                contextTreeChanges.deleted.length === 0) {
+                this.log('No context changes to push.');
+                return;
+            }
             // Prompt for confirmation unless --yes flag is provided
             if (!flags.yes) {
-                const confirmed = await this.confirmPush(projectConfig, flags.branch, 1);
+                const confirmed = await this.confirmPush(projectConfig, flags.branch);
                 if (!confirmed) {
-                    this.log('Push cancelled. No files were uploaded or cleaned.');
+                    this.log('Push cancelled.');
                     return;
                 }
             }
-            const response = await this.getPresignedUrls(memoryService, token, projectConfig);
-            const playbookContent = await this.loadPlaybookContent(playbookStore);
-            await this.uploadFiles(memoryService, response.presignedUrls, playbookContent);
-            await this.confirmUpload(memoryService, token, projectConfig, response.requestId);
-            await this.cleanUpLocalFiles(playbookStore);
+            // Read and prepare files
+            ux.action.start('Reading context files');
+            const [addedFiles, modifiedFiles] = await Promise.all([
+                contextFileReader.readMany(contextTreeChanges.added),
+                contextFileReader.readMany(contextTreeChanges.modified),
+            ]);
+            ux.action.stop();
+            const pushContexts = mapToPushContexts({
+                addedFiles,
+                deletedPaths: contextTreeChanges.deleted,
+                modifiedFiles,
+            });
+            if (pushContexts.length === 0) {
+                this.log('\nNo valid context files to push.');
+                return;
+            }
+            // Push to CoGit (with two-request SHA flow)
+            this.log('Pushing to ByteRover...');
+            await cogitPushService.push({
+                accessToken: token.accessToken,
+                branch: flags.branch,
+                contexts: pushContexts,
+                sessionKey: token.sessionKey,
+                spaceId: projectConfig.spaceId,
+                teamId: projectConfig.teamId,
+            });
+            // Update snapshot ONLY after successful push
+            await contextTreeSnapshotService.saveSnapshot();
             // Success message
-            this.log('\n✓ Successfully pushed playbook to ByteRover memory storage!');
+            this.log('\n✓ Successfully pushed context tree to ByteRover memory storage!');
             this.log(`  Branch: ${flags.branch}`);
-            this.log(`  Files uploaded: ${response.presignedUrls.length}`);
+            this.log(`  Added: ${addedFiles.length}, Edited: ${modifiedFiles.length}, Deleted: ${contextTreeChanges.deleted.length}`);
+            this.log(`  View: ${this.buildSpaceUrl(getCurrentConfig().webAppUrl, projectConfig.teamName, projectConfig.spaceName)}`);
         }
         catch (error) {
-            this.error(error instanceof Error ? error.message : 'Push failed');
+            if (error instanceof WorkspaceNotInitializedError) {
+                exitWithCode(ExitCode.VALIDATION_ERROR, 'Project not initialized. Please run "brv init" to select your team and workspace.');
+            }
+            // For other errors, use exitWithCode to properly display error before exit
+            const message = error instanceof Error ? error.message : 'Push failed';
+            exitWithCode(ExitCode.RUNTIME_ERROR, `Failed to push: ${message}`);
         }
     }
-    async uploadFiles(memoryService, presignedUrls, playbookContent) {
-        this.log('\nUploading files...');
-        ux.action.start('  Uploading files');
-        await Promise.all(presignedUrls.map((presignedUrl) => memoryService.uploadFile(presignedUrl.uploadUrl, playbookContent)));
-        ux.action.stop('✓');
-    }
     async validateAuth(tokenStore) {
         const token = await tokenStore.load();
         if (token === undefined) {
@@ -171,10 +157,4 @@ export default class Push extends Command {
         }
         return token;
     }
-    async verifyPlaybookExists(playbookStore) {
-        const playbookExists = await playbookStore.exists();
-        if (!playbookExists) {
-            this.error('Playbook not found. Run "brv init" to create one.');
-        }
-    }
 }

package/dist/commands/query.d.ts

@@ -0,0 +1,63 @@
+import { Command } from '@oclif/core';
+import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Query extends Command {
+    static args: {
+        query: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        apiKey?: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions> | undefined;
+        model?: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions> | undefined;
+        verbose?: import("@oclif/core/interfaces").BooleanFlag<boolean> | undefined;
+    };
+    static strict: boolean;
+    catch(error: Error & {
+        oclif?: {
+            exit: number;
+        };
+    }): Promise<void>;
+    protected createServices(): {
+        projectConfigStore: IProjectConfigStore;
+        trackingService: ITrackingService;
+    };
+    /**
+     * Generate a unique session ID for the query agent.
+     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
+     */
+    protected generateSessionId(): string;
+    run(): Promise<void>;
+    /**
+     * Format items count from list_directory result
+     */
+    private formatItemsCount;
+    /**
+     * Format matches count from grep_content result
+     */
+    private formatMatchesCount;
+    /**
+     * Format tool result summary for display
+     */
+    private formatToolResultSummary;
+    /**
+     * Format topics count from find_knowledge_topics result
+     */
+    private formatTopicsCount;
+    /**
+     * Get user-friendly description for a tool
+     *
+     * @param toolName - Name of the tool
+     * @param args - Tool arguments
+     * @returns User-friendly description
+     */
+    private getToolDescription;
+    /**
+     * Handle workspace not initialized error
+     */
+    private handleWorkspaceError;
+    /**
+     * Setup event listeners for CipherAgent
+     */
+    private setupEventListeners;
+}