byterover-cli 0.3.5 → 0.4.1

package/dist/infra/usecase/login-use-case.d.ts

@@ -0,0 +1,28 @@
+import type { IAuthService } from '../../core/interfaces/i-auth-service.js';
+import type { IBrowserLauncher } from '../../core/interfaces/i-browser-launcher.js';
+import type { ICallbackHandler } from '../../core/interfaces/i-callback-handler.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IUserService } from '../../core/interfaces/i-user-service.js';
+import type { ILoginUseCase } from '../../core/interfaces/usecase/i-login-use-case.js';
+export interface LoginUseCaseOptions {
+    authService: IAuthService;
+    browserLauncher: IBrowserLauncher;
+    callbackHandler: ICallbackHandler;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+    userService: IUserService;
+}
+export declare class LoginUseCase implements ILoginUseCase {
+    private readonly authService;
+    private readonly browserLauncher;
+    private readonly callbackHandler;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    private readonly userService;
+    constructor(options: LoginUseCaseOptions);
+    run(): Promise<void>;
+}

package/dist/infra/usecase/login-use-case.js

@@ -0,0 +1,94 @@
+import { AuthToken } from '../../core/domain/entities/auth-token.js';
+import { DiscoveryError } from '../../core/domain/errors/discovery-error.js';
+export class LoginUseCase {
+    authService;
+    browserLauncher;
+    callbackHandler;
+    terminal;
+    tokenStore;
+    trackingService;
+    userService;
+    constructor(options) {
+        this.authService = options.authService;
+        this.browserLauncher = options.browserLauncher;
+        this.callbackHandler = options.callbackHandler;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+        this.userService = options.userService;
+    }
+    async run() {
+        try {
+            await this.trackingService.track('auth:sign_in', { status: 'started' });
+            this.terminal.log('Starting authentication process...');
+            // Start callback server
+            await this.callbackHandler.start();
+            // Get port and build redirect URI
+            const port = this.callbackHandler.getPort();
+            if (!port) {
+                const getPortFailedErr = 'Failed to get callback server port';
+                await this.trackingService.track('auth:sign_in', { message: getPortFailedErr, status: 'error' });
+                throw new Error(getPortFailedErr);
+            }
+            const redirectUri = `http://localhost:${port}/callback`;
+            // Initiate authorization (generates PKCE parameters and state internally)
+            const authContext = this.authService.initiateAuthorization(redirectUri);
+            // Try to open browser
+            let browserOpened = false;
+            try {
+                await this.browserLauncher.open(authContext.authUrl);
+                browserOpened = true;
+            }
+            catch {
+                // Browser launch failed, will return URL to user
+                await this.trackingService.track('auth:sign_in', { message: 'browser launch failed', status: 'error' });
+            }
+            // If browser failed to open, display the URL for manual copy
+            if (!browserOpened) {
+                this.terminal.log('\nBrowser failed to open automatically.');
+                this.terminal.log('Please open this URL in your browser:');
+                this.terminal.log(authContext.authUrl);
+            }
+            try {
+                // Wait for callback with 5 minute timeout
+                const { code } = await this.callbackHandler.waitForCallback(authContext.state, 5 * 60 * 1000);
+                const authTokenData = await this.authService.exchangeCodeForToken(code, authContext, redirectUri);
+                const user = await this.userService.getCurrentUser(authTokenData.accessToken, authTokenData.sessionKey);
+                const authToken = new AuthToken({
+                    accessToken: authTokenData.accessToken,
+                    expiresAt: authTokenData.expiresAt,
+                    refreshToken: authTokenData.refreshToken,
+                    sessionKey: authTokenData.sessionKey,
+                    tokenType: authTokenData.tokenType,
+                    userEmail: user.email,
+                    userId: user.id,
+                });
+                await this.tokenStore.save(authToken);
+                await this.trackingService.track('auth:sign_in', { status: 'finished' });
+                this.terminal.log(`Logged in as ${user.email}`);
+            }
+            catch (error) {
+                // Throw error to let oclif handle display
+                const errorMessage = error instanceof Error ? error.message : 'Authentication failed';
+                await this.trackingService.track('auth:sign_in', { message: errorMessage, status: 'error' });
+                this.terminal.error(errorMessage);
+            }
+        }
+        catch (error) {
+            if (error instanceof DiscoveryError) {
+                const errorMessage = `Failed to configure authentication: ${error.message}\n` +
+                    'Please check your network connection and try again.';
+                await this.trackingService.track('auth:sign_in', { message: errorMessage, status: 'error' });
+                this.terminal.error(errorMessage);
+            }
+            // Throw error to let oclif handle display
+            const errorMessage = error instanceof Error ? error.message : 'Authentication failed';
+            await this.trackingService.track('auth:sign_in', { message: errorMessage, status: 'error' });
+            this.terminal.error(errorMessage);
+        }
+        finally {
+            // Always cleanup server
+            await this.callbackHandler.stop();
+        }
+    }
+}

package/dist/infra/usecase/logout-use-case.d.ts

@@ -0,0 +1,22 @@
+import type { IOnboardingPreferenceStore } from "../../core/interfaces/i-onboarding-preference-store.js";
+import type { ITerminal } from "../../core/interfaces/i-terminal.js";
+import type { ITokenStore } from "../../core/interfaces/i-token-store.js";
+import type { ITrackingService } from "../../core/interfaces/i-tracking-service.js";
+import type { ILogoutUseCase } from "../../core/interfaces/usecase/i-logout-use-case.js";
+export interface LogoutUseCaseDeps {
+    onboardingPreferenceStore: IOnboardingPreferenceStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+}
+export declare class LogoutUseCase implements ILogoutUseCase {
+    private readonly onboardingPreferenceStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    constructor(deps: LogoutUseCaseDeps);
+    protected confirmLogout(userEmail: string): Promise<boolean>;
+    run(options: {
+        skipConfirmation: boolean;
+    }): Promise<void>;
+}

package/dist/infra/usecase/logout-use-case.js

@@ -0,0 +1,51 @@
+export class LogoutUseCase {
+    onboardingPreferenceStore;
+    terminal;
+    tokenStore;
+    trackingService;
+    constructor(deps) {
+        this.onboardingPreferenceStore = deps.onboardingPreferenceStore;
+        this.terminal = deps.terminal;
+        this.tokenStore = deps.tokenStore;
+        this.trackingService = deps.trackingService;
+    }
+    async confirmLogout(userEmail) {
+        return this.terminal.confirm({
+            default: true,
+            message: `Logging out ${userEmail}. Are you sure?`,
+        });
+    }
+    async run(options) {
+        try {
+            const token = await this.tokenStore.load();
+            if (token === undefined) {
+                this.terminal.log("You are not currently logged in.");
+                return;
+            }
+            if (!options.skipConfirmation) {
+                const confirmed = await this.confirmLogout(token.userEmail);
+                if (!confirmed) {
+                    this.terminal.log("Logout cancelled");
+                    return;
+                }
+            }
+            try {
+                await this.trackingService.track("auth:signed_out");
+            }
+            catch {
+                // Tracking failures should not block logout
+            }
+            await this.tokenStore.clear();
+            await this.onboardingPreferenceStore.clear();
+            this.terminal.log("Successfully logged out.");
+            this.terminal.log("Run 'brv login' to authenticate again.");
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("keychain")) {
+                this.terminal.error("Unable to access system keychain. Please check your system permissions and try again.");
+                return;
+            }
+            this.terminal.error(error instanceof Error ? error.message : "Logout failed");
+        }
+    }
+}

package/dist/infra/usecase/pull-use-case.d.ts

@@ -0,0 +1,35 @@
+import type { AuthToken } from '../../core/domain/entities/auth-token.js';
+import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
+import type { ICogitPullService } from '../../core/interfaces/i-cogit-pull-service.js';
+import type { IContextTreeSnapshotService } from '../../core/interfaces/i-context-tree-snapshot-service.js';
+import type { IContextTreeWriterService } from '../../core/interfaces/i-context-tree-writer-service.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IPullUseCase } from '../../core/interfaces/usecase/i-pull-use-case.js';
+export interface PullUseCaseOptions {
+    cogitPullService: ICogitPullService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    contextTreeWriterService: IContextTreeWriterService;
+    projectConfigStore: IProjectConfigStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+}
+export declare class PullUseCase implements IPullUseCase {
+    private readonly cogitPullService;
+    private readonly contextTreeSnapshotService;
+    private readonly contextTreeWriterService;
+    private readonly projectConfigStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    constructor(options: PullUseCaseOptions);
+    protected checkLocalChanges(): Promise<boolean>;
+    protected checkProjectInit(): Promise<BrvConfig>;
+    run(options: {
+        branch: string;
+    }): Promise<void>;
+    protected validateAuth(): Promise<AuthToken | undefined>;
+}

package/dist/infra/usecase/pull-use-case.js

@@ -0,0 +1,89 @@
+import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
+export class PullUseCase {
+    cogitPullService;
+    contextTreeSnapshotService;
+    contextTreeWriterService;
+    projectConfigStore;
+    terminal;
+    tokenStore;
+    trackingService;
+    constructor(options) {
+        this.cogitPullService = options.cogitPullService;
+        this.contextTreeSnapshotService = options.contextTreeSnapshotService;
+        this.contextTreeWriterService = options.contextTreeWriterService;
+        this.projectConfigStore = options.projectConfigStore;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+    }
+    async checkLocalChanges() {
+        const changes = await this.contextTreeSnapshotService.getChanges();
+        return changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+    }
+    async checkProjectInit() {
+        const projectConfig = await this.projectConfigStore.read();
+        if (projectConfig === undefined) {
+            throw new WorkspaceNotInitializedError('Project not initialized. Please run "brv init" to select your team and workspace.', '.brv');
+        }
+        return projectConfig;
+    }
+    async run(options) {
+        try {
+            await this.trackingService.track('mem:pull');
+            const token = await this.validateAuth();
+            if (!token)
+                return;
+            const projectConfig = await this.checkProjectInit();
+            // Check for local changes
+            this.terminal.actionStart('Checking for local Context Tree changes');
+            const hasLocalChanges = await this.checkLocalChanges();
+            this.terminal.actionStop();
+            if (hasLocalChanges) {
+                this.terminal.log('You have local changes that have not been pushed. Run "brv push" first.');
+                return;
+            }
+            // Pull from CoGit
+            this.terminal.log('Pulling from ByteRover...');
+            const snapshot = await this.cogitPullService.pull({
+                accessToken: token.accessToken,
+                branch: options.branch,
+                sessionKey: token.sessionKey,
+                spaceId: projectConfig.spaceId,
+                teamId: projectConfig.teamId,
+            });
+            // Sync files to local context tree
+            this.terminal.actionStart('Syncing context files');
+            const syncResult = await this.contextTreeWriterService.sync({ files: snapshot.files });
+            this.terminal.actionStop();
+            // Update snapshot ONLY after successful sync
+            await this.contextTreeSnapshotService.saveSnapshot();
+            // Success message
+            this.terminal.log('\n✓ Successfully pulled context tree from ByteRover memory storage!');
+            this.terminal.log(`  Branch: ${options.branch}`);
+            this.terminal.log(`  Commit: ${snapshot.commitSha.slice(0, 7)}`);
+            this.terminal.log(`  Added: ${syncResult.added.length}, Edited: ${syncResult.edited.length}, Deleted: ${syncResult.deleted.length}`);
+        }
+        catch (error) {
+            // Stop action if it's in progress
+            this.terminal.actionStop();
+            if (error instanceof WorkspaceNotInitializedError) {
+                this.terminal.log('Project not initialized. Please run "brv init" to select your team and workspace.');
+                return;
+            }
+            const message = error instanceof Error ? error.message : 'Pull failed';
+            this.terminal.error(`Failed to pull: ${message}`);
+        }
+    }
+    async validateAuth() {
+        const token = await this.tokenStore.load();
+        if (token === undefined) {
+            this.terminal.error('Not authenticated. Run "brv login" first.');
+            return undefined;
+        }
+        if (!token.isValid()) {
+            this.terminal.error('Authentication token expired. Run "brv login" again.');
+            return undefined;
+        }
+        return token;
+    }
+}

package/dist/infra/usecase/push-use-case.d.ts

@@ -0,0 +1,37 @@
+import type { ICogitPushService } from '../../core/interfaces/i-cogit-push-service.js';
+import type { IContextFileReader } from '../../core/interfaces/i-context-file-reader.js';
+import type { IContextTreeSnapshotService } from '../../core/interfaces/i-context-tree-snapshot-service.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IPushUseCase } from '../../core/interfaces/usecase/i-push-use-case.js';
+export interface PushUseCaseOptions {
+    cogitPushService: ICogitPushService;
+    contextFileReader: IContextFileReader;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    projectConfigStore: IProjectConfigStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+    webAppUrl: string;
+}
+export declare class PushUseCase implements IPushUseCase {
+    private readonly cogitPushService;
+    private readonly contextFileReader;
+    private readonly contextTreeSnapshotService;
+    private readonly projectConfigStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    private readonly webAppUrl;
+    constructor(options: PushUseCaseOptions);
+    run(options: {
+        branch: string;
+        skipConfirmation: boolean;
+    }): Promise<void>;
+    private buildSpaceUrl;
+    private checkProjectInit;
+    private confirmPush;
+    private validateAuth;
+}

package/dist/infra/usecase/push-use-case.js

@@ -0,0 +1,124 @@
+import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
+import { mapToPushContexts } from '../cogit/context-tree-to-push-context-mapper.js';
+export class PushUseCase {
+    cogitPushService;
+    contextFileReader;
+    contextTreeSnapshotService;
+    projectConfigStore;
+    terminal;
+    tokenStore;
+    trackingService;
+    webAppUrl;
+    constructor(options) {
+        this.cogitPushService = options.cogitPushService;
+        this.contextFileReader = options.contextFileReader;
+        this.contextTreeSnapshotService = options.contextTreeSnapshotService;
+        this.projectConfigStore = options.projectConfigStore;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+        this.webAppUrl = options.webAppUrl;
+    }
+    async run(options) {
+        try {
+            await this.trackingService.track('mem:push');
+            const token = await this.validateAuth();
+            if (!token)
+                return;
+            const projectConfig = await this.checkProjectInit();
+            // Check for changes
+            this.terminal.actionStart('Checking for Context Tree changes');
+            const contextTreeChanges = await this.contextTreeSnapshotService.getChanges();
+            this.terminal.actionStop();
+            if (contextTreeChanges.added.length === 0 &&
+                contextTreeChanges.modified.length === 0 &&
+                contextTreeChanges.deleted.length === 0) {
+                this.terminal.log('No context changes to push.');
+                return;
+            }
+            // Prompt for confirmation unless skipConfirmation is true
+            if (!options.skipConfirmation) {
+                const confirmed = await this.confirmPush(projectConfig, options.branch);
+                if (!confirmed) {
+                    this.terminal.log('Push cancelled.');
+                    return;
+                }
+            }
+            // Read and prepare files
+            this.terminal.actionStart('Reading context files');
+            const [addedFiles, modifiedFiles] = await Promise.all([
+                this.contextFileReader.readMany(contextTreeChanges.added),
+                this.contextFileReader.readMany(contextTreeChanges.modified),
+            ]);
+            this.terminal.actionStop();
+            const pushContexts = mapToPushContexts({
+                addedFiles,
+                deletedPaths: contextTreeChanges.deleted,
+                modifiedFiles,
+            });
+            if (pushContexts.length === 0) {
+                this.terminal.log('\nNo valid context files to push.');
+                return;
+            }
+            // Push to CoGit (with two-request SHA flow)
+            this.terminal.log('Pushing to ByteRover...');
+            await this.cogitPushService.push({
+                accessToken: token.accessToken,
+                branch: options.branch,
+                contexts: pushContexts,
+                sessionKey: token.sessionKey,
+                spaceId: projectConfig.spaceId,
+                teamId: projectConfig.teamId,
+            });
+            // Update snapshot ONLY after successful push
+            await this.contextTreeSnapshotService.saveSnapshot();
+            // Success message
+            this.terminal.log('\n✓ Successfully pushed context tree to ByteRover memory storage!');
+            this.terminal.log(`  Branch: ${options.branch}`);
+            this.terminal.log(`  Added: ${addedFiles.length}, Edited: ${modifiedFiles.length}, Deleted: ${contextTreeChanges.deleted.length}`);
+            this.terminal.log(`  View: ${this.buildSpaceUrl(projectConfig.teamName, projectConfig.spaceName)}`);
+        }
+        catch (error) {
+            // Stop action if it's in progress
+            this.terminal.actionStop();
+            if (error instanceof WorkspaceNotInitializedError) {
+                this.terminal.log('Project not initialized. Please run "brv init" to select your team and workspace.');
+                return;
+            }
+            // For other errors, to properly display error before exit
+            const message = error instanceof Error ? error.message : 'Push failed';
+            this.terminal.error(`Failed to push: ${message}`);
+        }
+    }
+    buildSpaceUrl(teamName, spaceName) {
+        return `${this.webAppUrl}/${teamName}/${spaceName}`;
+    }
+    async checkProjectInit() {
+        const projectConfig = await this.projectConfigStore.read();
+        if (projectConfig === undefined) {
+            throw new WorkspaceNotInitializedError('Project not initialized. Please run "brv init" to select your team and workspace.', '.brv');
+        }
+        return projectConfig;
+    }
+    async confirmPush(projectConfig, branch) {
+        this.terminal.log('\nYou are about to push to ByteRover memory storage:');
+        this.terminal.log(`  Space: ${projectConfig.spaceName}`);
+        this.terminal.log(`  Branch: ${branch}`);
+        return this.terminal.confirm({
+            default: false,
+            message: 'Push to ByteRover?',
+        });
+    }
+    async validateAuth() {
+        const token = await this.tokenStore.load();
+        if (token === undefined) {
+            this.terminal.error('Not authenticated. Run "brv login" first.');
+            return undefined;
+        }
+        if (!token.isValid()) {
+            this.terminal.error('Authentication token expired. Run "brv login" again.');
+            return undefined;
+        }
+        return token;
+    }
+}

package/dist/infra/usecase/query-use-case.d.ts

@@ -0,0 +1,78 @@
+import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { IQueryUseCase, QueryUseCaseRunOptions } from '../../core/interfaces/usecase/i-query-use-case.js';
+import { CipherAgent } from '../cipher/cipher-agent.js';
+export interface QueryUseCaseOptions {
+    projectConfigStore: IProjectConfigStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+}
+export declare class QueryUseCase implements IQueryUseCase {
+    private readonly projectConfigStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    constructor(options: QueryUseCaseOptions);
+    /**
+     * Create CipherAgent instance. Protected to allow test overrides.
+     */
+    protected createCipherAgent(llmConfig: any, brvConfig: BrvConfig): CipherAgent;
+    /**
+     * Generate a unique session ID for the query agent.
+     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
+     */
+    protected generateSessionId(): string;
+    run(options: QueryUseCaseRunOptions): Promise<void>;
+    /**
+     * Create result summary for tool call
+     */
+    private createResultSummary;
+    /**
+     * Extract summary from curate tool result
+     */
+    private extractCurateSummary;
+    /**
+     * Format curate tool operation summary
+     */
+    private formatCurateResult;
+    /**
+     * 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;
+    /**
+     * Setup tool call tracking to persist in database
+     */
+    private setupToolCallTracking;
+}