byterover-cli 1.5.0 → 1.6.0

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

@@ -5,24 +5,26 @@ 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';
+import type { ILoginUseCase, LoginUseCaseRunOptions } from '../../core/interfaces/usecase/i-login-use-case.js';
 export interface LoginUseCaseOptions {
-    authService: IAuthService;
-    browserLauncher: IBrowserLauncher;
-    callbackHandler: ICallbackHandler;
+    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 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>;
+    run({ apiKey }?: LoginUseCaseRunOptions): Promise<void>;
+    runLoginManually(): Promise<void>;
+    runLoginWithApiKey(apiKey: string): Promise<void>;
 }

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

@@ -17,7 +17,13 @@ export class LoginUseCase {
         this.trackingService = options.trackingService;
         this.userService = options.userService;
     }
-    async run() {
+    async run({ apiKey } = {}) {
+        return apiKey ? this.runLoginWithApiKey(apiKey) : this.runLoginManually();
+    }
+    async runLoginManually() {
+        if (!this.authService || !this.browserLauncher || !this.callbackHandler) {
+            throw new Error('OAuth services are required for manual login');
+        }
         try {
             await this.trackingService.track('auth:sign_in', { status: 'started' });
             this.terminal.log('Starting authentication process...');
@@ -53,7 +59,7 @@ export class LoginUseCase {
                 // 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 user = await this.userService.getCurrentUser(authTokenData.sessionKey);
                 const authToken = new AuthToken({
                     accessToken: authTokenData.accessToken,
                     expiresAt: authTokenData.expiresAt,
@@ -91,4 +97,31 @@ export class LoginUseCase {
             await this.callbackHandler.stop();
         }
     }
+    async runLoginWithApiKey(apiKey) {
+        try {
+            await this.trackingService.track('auth:sign_in', { status: 'started' });
+            this.terminal.log('Logging in...');
+            const user = await this.userService.getCurrentUser(apiKey);
+            // eslint-disable-next-line no-warning-comments
+            // TODO: accessToken, refreshToken, and tokenType do not appear to be necessary; consider removing them.
+            const authToken = new AuthToken({
+                accessToken: 'unnecessary',
+                expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // 30 days
+                refreshToken: 'unnecessary',
+                sessionKey: apiKey,
+                tokenType: 'unnecessary',
+                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.log(errorMessage);
+        }
+    }
 }

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

@@ -7,7 +7,19 @@ import type { IProjectConfigStore } from '../../core/interfaces/i-project-config
 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';
+import type { IPullUseCase, PullUseCaseRunOptions } from '../../core/interfaces/usecase/i-pull-use-case.js';
+/**
+ * Structured pull result for JSON output.
+ */
+export interface PullResult {
+    added?: number;
+    branch?: string;
+    commitSha?: string;
+    deleted?: number;
+    edited?: number;
+    error?: string;
+    status: 'error' | 'local_changes' | 'success';
+}
 export interface PullUseCaseOptions {
     cogitPullService: ICogitPullService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
@@ -28,8 +40,10 @@ export declare class PullUseCase implements IPullUseCase {
     constructor(options: PullUseCaseOptions);
     protected checkLocalChanges(): Promise<boolean>;
     protected checkProjectInit(): Promise<BrvConfig>;
-    run(options: {
-        branch: string;
-    }): Promise<void>;
-    protected validateAuth(): Promise<AuthToken | undefined>;
+    run(options: PullUseCaseRunOptions): Promise<void>;
+    protected validateAuth(format: 'json' | 'text'): Promise<AuthToken | undefined>;
+    /**
+     * Output JSON result for headless mode.
+     */
+    private outputJsonResult;
 }

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

@@ -1,4 +1,5 @@
 import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
+import { HeadlessTerminal } from '../terminal/headless-terminal.js';
 export class PullUseCase {
     cogitPullService;
     contextTreeSnapshotService;
@@ -28,9 +29,10 @@ export class PullUseCase {
         return projectConfig;
     }
     async run(options) {
+        const format = options.format ?? 'text';
         try {
             await this.trackingService.track('mem:pull');
-            const token = await this.validateAuth();
+            const token = await this.validateAuth(format);
             if (!token)
                 return;
             const projectConfig = await this.checkProjectInit();
@@ -39,13 +41,20 @@ export class PullUseCase {
             const hasLocalChanges = await this.checkLocalChanges();
             this.terminal.actionStop();
             if (hasLocalChanges) {
-                this.terminal.log('You have local changes that have not been pushed. Run "/push" first.');
+                if (format === 'json') {
+                    this.outputJsonResult({
+                        error: 'You have local changes that have not been pushed. Run push first.',
+                        status: 'local_changes',
+                    });
+                }
+                else {
+                    this.terminal.log('You have local changes that have not been pushed. Run "/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,
@@ -57,33 +66,82 @@ export class PullUseCase {
             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}`);
+            if (format === 'json') {
+                this.outputJsonResult({
+                    added: syncResult.added.length,
+                    branch: options.branch,
+                    commitSha: snapshot.commitSha,
+                    deleted: syncResult.deleted.length,
+                    edited: syncResult.edited.length,
+                    status: 'success',
+                });
+            }
+            else {
+                // 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 "/init" to select your team and workspace.');
+                if (format === 'json') {
+                    this.outputJsonResult({ error: 'Project not initialized. Run init first.', status: 'error' });
+                }
+                else {
+                    this.terminal.log('Project not initialized. Please run "/init" to select your team and workspace.');
+                }
                 return;
             }
             const message = error instanceof Error ? error.message : 'Pull failed';
-            this.terminal.error(`Failed to pull: ${message}`);
+            if (format === 'json') {
+                this.outputJsonResult({ error: message, status: 'error' });
+            }
+            else {
+                this.terminal.error(`Failed to pull: ${message}`);
+            }
         }
     }
-    async validateAuth() {
+    async validateAuth(format) {
         const token = await this.tokenStore.load();
         if (token === undefined) {
-            this.terminal.error('Not authenticated. Run "/login" first.');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Not authenticated. Run login first.', status: 'error' });
+            }
+            else {
+                this.terminal.error('Not authenticated. Run "/login" first.');
+            }
             return undefined;
         }
         if (!token.isValid()) {
-            this.terminal.error('Authentication token expired. Run "/login" again.');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Authentication token expired. Run login again.', status: 'error' });
+            }
+            else {
+                this.terminal.error('Authentication token expired. Run "/login" again.');
+            }
             return undefined;
         }
         return token;
     }
+    /**
+     * Output JSON result for headless mode.
+     */
+    outputJsonResult(result) {
+        const response = {
+            command: 'pull',
+            data: result,
+            success: result.status === 'success',
+            timestamp: new Date().toISOString(),
+        };
+        if (this.terminal instanceof HeadlessTerminal) {
+            this.terminal.writeFinalResponse(response);
+        }
+        else {
+            this.terminal.log(JSON.stringify(response));
+        }
+    }
 }

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

@@ -5,7 +5,19 @@ import type { IProjectConfigStore } from '../../core/interfaces/i-project-config
 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';
+import type { IPushUseCase, PushUseCaseRunOptions } from '../../core/interfaces/usecase/i-push-use-case.js';
+/**
+ * Structured push result for JSON output.
+ */
+export interface PushResult {
+    added?: number;
+    branch?: string;
+    deleted?: number;
+    edited?: number;
+    error?: string;
+    status: 'cancelled' | 'error' | 'no_changes' | 'success';
+    url?: string;
+}
 export interface PushUseCaseOptions {
     cogitPushService: ICogitPushService;
     contextFileReader: IContextFileReader;
@@ -26,12 +38,13 @@ export declare class PushUseCase implements IPushUseCase {
     private readonly trackingService;
     private readonly webAppUrl;
     constructor(options: PushUseCaseOptions);
-    run(options: {
-        branch: string;
-        skipConfirmation: boolean;
-    }): Promise<void>;
+    run(options: PushUseCaseRunOptions): Promise<void>;
     private buildSpaceUrl;
     private checkProjectInit;
     private confirmPush;
+    /**
+     * Output JSON result for headless mode.
+     */
+    private outputJsonResult;
     private validateAuth;
 }

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

@@ -1,5 +1,6 @@
 import { WorkspaceNotInitializedError } from '../cipher/validation/workspace-validator.js';
 import { mapToPushContexts } from '../cogit/context-tree-to-push-context-mapper.js';
+import { HeadlessTerminal } from '../terminal/headless-terminal.js';
 export class PushUseCase {
     cogitPushService;
     contextFileReader;
@@ -20,9 +21,10 @@ export class PushUseCase {
         this.webAppUrl = options.webAppUrl;
     }
     async run(options) {
+        const format = options.format ?? 'text';
         try {
             await this.trackingService.track('mem:push');
-            const token = await this.validateAuth();
+            const token = await this.validateAuth(format);
             if (!token)
                 return;
             const projectConfig = await this.checkProjectInit();
@@ -33,14 +35,24 @@ export class PushUseCase {
             if (contextTreeChanges.added.length === 0 &&
                 contextTreeChanges.modified.length === 0 &&
                 contextTreeChanges.deleted.length === 0) {
-                this.terminal.log('No context changes to push.');
+                if (format === 'json') {
+                    this.outputJsonResult({ status: 'no_changes' });
+                }
+                else {
+                    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.');
+                    if (format === 'json') {
+                        this.outputJsonResult({ status: 'cancelled' });
+                    }
+                    else {
+                        this.terminal.log('Push cancelled.');
+                    }
                     return;
                 }
             }
@@ -57,7 +69,12 @@ export class PushUseCase {
                 modifiedFiles,
             });
             if (pushContexts.length === 0) {
-                this.terminal.log('\nNo valid context files to push.');
+                if (format === 'json') {
+                    this.outputJsonResult({ status: 'no_changes' });
+                }
+                else {
+                    this.terminal.log('\nNo valid context files to push.');
+                }
                 return;
             }
             // Push to CoGit (with two-request SHA flow)
@@ -72,22 +89,45 @@ export class PushUseCase {
             });
             // 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)}`);
+            const url = this.buildSpaceUrl(projectConfig.teamName, projectConfig.spaceName);
+            if (format === 'json') {
+                this.outputJsonResult({
+                    added: addedFiles.length,
+                    branch: options.branch,
+                    deleted: contextTreeChanges.deleted.length,
+                    edited: modifiedFiles.length,
+                    status: 'success',
+                    url,
+                });
+            }
+            else {
+                // 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: ${url}`);
+            }
         }
         catch (error) {
             // Stop action if it's in progress
             this.terminal.actionStop();
             if (error instanceof WorkspaceNotInitializedError) {
-                this.terminal.log('Project not initialized. Please run "/init" to select your team and workspace.');
+                if (format === 'json') {
+                    this.outputJsonResult({ error: 'Project not initialized. Run init first.', status: 'error' });
+                }
+                else {
+                    this.terminal.log('Project not initialized. Please run "/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}`);
+            if (format === 'json') {
+                this.outputJsonResult({ error: message, status: 'error' });
+            }
+            else {
+                this.terminal.error(`Failed to push: ${message}`);
+            }
         }
     }
     buildSpaceUrl(teamName, spaceName) {
@@ -109,14 +149,41 @@ export class PushUseCase {
             message: 'Push to ByteRover',
         });
     }
-    async validateAuth() {
+    /**
+     * Output JSON result for headless mode.
+     */
+    outputJsonResult(result) {
+        const response = {
+            command: 'push',
+            data: result,
+            success: result.status === 'success',
+            timestamp: new Date().toISOString(),
+        };
+        if (this.terminal instanceof HeadlessTerminal) {
+            this.terminal.writeFinalResponse(response);
+        }
+        else {
+            this.terminal.log(JSON.stringify(response));
+        }
+    }
+    async validateAuth(format) {
         const token = await this.tokenStore.load();
         if (token === undefined) {
-            this.terminal.error('Not authenticated. Run "/login" first.');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Not authenticated. Run login first.', status: 'error' });
+            }
+            else {
+                this.terminal.error('Not authenticated. Run "/login" first.');
+            }
             return undefined;
         }
         if (!token.isValid()) {
-            this.terminal.error('Authentication token expired. Run "/login" again.');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Authentication token expired. Run login again.', status: 'error' });
+            }
+            else {
+                this.terminal.error('Authentication token expired. Run "/login" again.');
+            }
             return undefined;
         }
         return token;

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

@@ -4,6 +4,19 @@ import type { ITrackingService } from '../../core/interfaces/i-tracking-service.
 import type { IQueryUseCase, QueryUseCaseRunOptions } from '../../core/interfaces/usecase/i-query-use-case.js';
 import { CipherAgent } from '../cipher/agent/index.js';
 import { type TransportClientFactory } from '../transport/transport-client-factory.js';
+/**
+ * Structured query result for JSON output.
+ */
+export interface QueryResult {
+    error?: string;
+    result?: string;
+    status: 'completed' | 'error';
+    toolCalls?: Array<{
+        status: string;
+        summary: string;
+        tool: string;
+    }>;
+}
 export type TransportClientFactoryCreator = () => TransportClientFactory;
 export interface QueryUseCaseOptions {
     terminal: ITerminal;
@@ -44,6 +57,14 @@ export declare class QueryUseCase implements IQueryUseCase {
      * Handle connection-related errors with user-friendly messages.
      */
     private handleConnectionError;
+    /**
+     * Handle connection errors with JSON output.
+     */
+    private handleConnectionErrorJson;
+    /**
+     * Output JSON result for headless mode.
+     */
+    private outputJsonResult;
     /**
      * Stream task results from the connected instance.
      */