byterover-cli 1.5.0 → 1.6.0

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

@@ -3,6 +3,8 @@ import { ConnectionError, ConnectionFailedError, InstanceCrashedError, NoInstanc
 import { formatError } from '../../utils/error-handler.js';
 import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError } from '../../utils/sandbox-detector.js';
 import { CipherAgent } from '../cipher/agent/index.js';
+import { InlineAgent } from '../process/inline-agent-executor.js';
+import { HeadlessTerminal } from '../terminal/headless-terminal.js';
 import { createTransportClientFactory } from '../transport/transport-client-factory.js';
 export class QueryUseCase {
     terminal;
@@ -29,21 +31,33 @@ export class QueryUseCase {
     }
     async run(options) {
         await this.trackingService.track('mem:query', { status: 'started' });
+        const format = options.format ?? 'text';
         if (!options.query.trim()) {
-            this.terminal.log('Query argument is required.');
-            this.terminal.log('Usage: brv query "your question here"');
+            if (format === 'json') {
+                this.outputJsonResult({ error: 'Query argument is required', status: 'error' });
+            }
+            else {
+                this.terminal.log('Query argument is required.');
+                this.terminal.log('Usage: brv query "your question here"');
+            }
             return;
         }
         const verbose = options.verbose || false;
-        // Connect to running instance
+        // Connect to running instance or create inline agent
         let client;
         try {
-            const transportClientFactory = this.transportClientFactoryCreator();
-            if (verbose) {
-                this.terminal.log('Discovering running instance...');
+            if (options.headless) {
+                const inlineAgent = await InlineAgent.create();
+                client = inlineAgent.transportClient;
+            }
+            else {
+                const transportClientFactory = this.transportClientFactoryCreator();
+                if (verbose) {
+                    this.terminal.log('Discovering running instance...');
+                }
+                const { client: connectedClient } = await transportClientFactory.connect();
+                client = connectedClient;
             }
-            const { client: connectedClient } = await transportClientFactory.connect();
-            client = connectedClient;
             if (verbose) {
                 this.terminal.log(`Connected to instance (clientId: ${client.getClientId()})`);
             }
@@ -60,11 +74,16 @@ export class QueryUseCase {
                 this.terminal.log(`Task created: ${taskId}`);
             }
             // Wait for task completion with streaming
-            await this.streamTaskResults(client, taskId, verbose);
+            await this.streamTaskResults(client, taskId, verbose, format);
             await this.trackingService.track('mem:query', { status: 'finished' });
         }
         catch (error) {
-            this.handleConnectionError(error);
+            if (format === 'json') {
+                this.handleConnectionErrorJson(error);
+            }
+            else {
+                this.handleConnectionError(error);
+            }
             await this.trackingService.track('mem:query', { message: formatError(error), status: 'error' });
         }
         finally {
@@ -233,19 +252,66 @@ export class QueryUseCase {
         const message = error instanceof Error ? error.message : String(error);
         this.terminal.log(`Unexpected error: ${message}`);
     }
+    /**
+     * Handle connection errors with JSON output.
+     */
+    handleConnectionErrorJson(error) {
+        let errorMessage = 'An unexpected error occurred';
+        if (error instanceof NoInstanceRunningError) {
+            errorMessage = 'No ByteRover instance is running. Start one with: brv';
+        }
+        else if (error instanceof InstanceCrashedError) {
+            errorMessage = 'ByteRover instance has crashed. Please restart with: brv';
+        }
+        else if (error instanceof ConnectionFailedError) {
+            errorMessage = `Failed to connect to ByteRover instance: ${error.message}`;
+        }
+        else if (error instanceof ConnectionError) {
+            errorMessage = `Connection error: ${error.message}`;
+        }
+        else if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        this.outputJsonResult({ error: errorMessage, status: 'error' });
+    }
+    /**
+     * Output JSON result for headless mode.
+     */
+    outputJsonResult(result) {
+        const response = {
+            command: 'query',
+            data: result,
+            success: result.status !== 'error',
+            timestamp: new Date().toISOString(),
+        };
+        if (this.terminal instanceof HeadlessTerminal) {
+            this.terminal.writeFinalResponse(response);
+        }
+        else {
+            this.terminal.log(JSON.stringify(response));
+        }
+    }
     /**
      * Stream task results from the connected instance.
      */
-    async streamTaskResults(client, taskId, verbose) {
+    async streamTaskResults(client, taskId, verbose, format = 'text') {
         return new Promise((resolve, reject) => {
             let completed = false;
             let resultPrinted = false; // Track if we've already printed the result
+            let finalResult;
+            const toolCalls = [];
             // Timeout after 5 minutes
             const timeout = setTimeout(() => {
                 if (!completed) {
                     completed = true;
                     cleanup();
-                    reject(new Error('Task timed out after 5 minutes'));
+                    if (format === 'json') {
+                        this.outputJsonResult({ error: 'Task timed out after 5 minutes', status: 'error' });
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Task timed out after 5 minutes'));
+                    }
                 }
             }, 5 * 60 * 1000);
             // Setup all event handlers
@@ -262,22 +328,15 @@ export class QueryUseCase {
                         this.terminal.log('Task started processing...');
                     }
                 }),
-                // llmservice:chunk - streaming content (for future release)
-                // client.on<LlmChunkPayload>('llmservice:chunk', (payload) => {
-                //   if (payload.taskId === taskId) {
-                //     if (!hasReceivedChunks) {
-                //       this.terminal.log('\nResult:')
-                //     }
-                //     hasReceivedChunks = true
-                //     process.stdout.write(payload.content)
-                //   }
-                // }),
                 // llmservice:response - final response from LLM (only print once)
                 client.on('llmservice:response', (payload) => {
                     if (payload.taskId === taskId && payload.content && !resultPrinted) {
                         resultPrinted = true;
-                        this.terminal.log('\nResult:');
-                        this.terminal.log(payload.content);
+                        finalResult = payload.content;
+                        if (format === 'text') {
+                            this.terminal.log('\nResult:');
+                            this.terminal.log(payload.content);
+                        }
                     }
                 }),
                 // llmservice:toolCall - tool invocation (stop showing after response)
@@ -285,7 +344,11 @@ export class QueryUseCase {
                     if (payload.taskId === taskId && !resultPrinted) {
                         const detail = payload.args ? this.formatToolArgs(payload.toolName, payload.args) : '';
                         const suffix = detail ? `: ${detail}` : '';
-                        this.terminal.log(`🔧 ${payload.toolName}${suffix}`);
+                        if (format === 'text') {
+                            this.terminal.log(`🔧 ${payload.toolName}${suffix}`);
+                        }
+                        // Track tool call for JSON output
+                        toolCalls.push({ status: 'started', summary: suffix, tool: payload.toolName });
                     }
                 }),
                 // llmservice:toolResult - tool result with summary (stop showing after response)
@@ -293,7 +356,15 @@ export class QueryUseCase {
                     if (payload.taskId === taskId && !resultPrinted) {
                         const status = payload.success ? '✓' : '✗';
                         const resultSummary = this.formatToolResult(payload);
-                        this.terminal.log(`  ${status} ${resultSummary}`);
+                        if (format === 'text') {
+                            this.terminal.log(`  ${status} ${resultSummary}`);
+                        }
+                        // Update last tool call with result
+                        const lastCall = toolCalls.at(-1);
+                        if (lastCall) {
+                            lastCall.status = payload.success ? 'success' : 'failed';
+                            lastCall.summary = resultSummary;
+                        }
                     }
                 }),
                 // task:completed - task finished (chunks already streamed, just resolve)
@@ -301,8 +372,16 @@ export class QueryUseCase {
                     if (payload.taskId === taskId && !completed) {
                         completed = true;
                         cleanup();
-                        // Note: Don't log result here - chunks already streamed it
-                        this.terminal.log(''); // Final newline for clean output
+                        if (format === 'json') {
+                            this.outputJsonResult({
+                                result: finalResult,
+                                status: 'completed',
+                                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                            });
+                        }
+                        else {
+                            this.terminal.log(''); // Final newline for clean output
+                        }
                         resolve();
                     }
                 }),
@@ -311,7 +390,13 @@ export class QueryUseCase {
                     if (payload.taskId === taskId && !completed) {
                         completed = true;
                         cleanup();
-                        reject(new Error(payload.error.message));
+                        if (format === 'json') {
+                            this.outputJsonResult({ error: payload.error.message, status: 'error' });
+                            resolve();
+                        }
+                        else {
+                            reject(new Error(payload.error.message));
+                        }
                     }
                 }),
                 // Clear timeout when done

package/dist/infra/usecase/space-list-use-case.js

@@ -29,7 +29,7 @@ export class SpaceListUseCase {
         }
         // Fetch spaces for the team from project config
         this.terminal.actionStart(`Fetching spaces for ${projectConfig.teamName}`);
-        const result = await this.spaceService.getSpaces(token.accessToken, token.sessionKey, projectConfig.teamId, this.flags.all ? { fetchAll: true } : { limit: this.flags.limit, offset: this.flags.offset });
+        const result = await this.spaceService.getSpaces(token.sessionKey, projectConfig.teamId, this.flags.all ? { fetchAll: true } : { limit: this.flags.limit, offset: this.flags.offset });
         this.terminal.actionStop();
         // Handle empty results
         if (result.spaces.length === 0) {

package/dist/infra/usecase/space-switch-use-case.js

@@ -67,7 +67,7 @@ export class SpaceSwitchUseCase {
         }
         // Fetch all teams
         this.terminal.actionStart('Fetching all teams');
-        const teamResult = await this.teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
+        const teamResult = await this.teamService.getTeams(token.sessionKey, { fetchAll: true });
         this.terminal.actionStop();
         if (teamResult.teams.length === 0) {
             this.terminal.log('No teams found. Please create a team in the ByteRover dashboard first.');
@@ -80,7 +80,7 @@ export class SpaceSwitchUseCase {
             return;
         // Fetch spaces for selected team
         this.terminal.actionStart('Fetching all spaces');
-        const spaceResult = await this.spaceService.getSpaces(token.accessToken, token.sessionKey, selectedTeam.id, {
+        const spaceResult = await this.spaceService.getSpaces(token.sessionKey, selectedTeam.id, {
             fetchAll: true,
         });
         this.terminal.actionStop();

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

@@ -6,6 +6,25 @@ import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
 import type { IInstanceDiscovery } from '../../core/interfaces/instance/i-instance-discovery.js';
 import type { IStatusUseCase } from '../../core/interfaces/usecase/i-status-use-case.js';
+/**
+ * Structured status data for JSON output.
+ */
+export interface StatusData {
+    authStatus: 'expired' | 'logged_in' | 'not_logged_in' | 'unknown';
+    cliVersion: string;
+    contextTreeChanges?: {
+        added: string[];
+        deleted: string[];
+        modified: string[];
+    };
+    contextTreeStatus: 'has_changes' | 'no_changes' | 'not_initialized' | 'unknown';
+    currentDirectory: string;
+    mcpStatus: 'connected' | 'crashed' | 'error' | 'no_instance' | 'not_responsive';
+    projectInitialized: boolean;
+    spaceName?: string;
+    teamName?: string;
+    userEmail?: string;
+}
 export interface StatusUseCaseOptions {
     contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
@@ -26,6 +45,7 @@ export declare class StatusUseCase implements IStatusUseCase {
     constructor(options: StatusUseCaseOptions);
     run(options: {
         cliVersion: string;
+        format?: 'json' | 'text';
     }): Promise<void>;
     /**
      * Checks the MCP connection status by:
@@ -34,4 +54,20 @@ export declare class StatusUseCase implements IStatusUseCase {
      * 3. Verifying bidirectional communication with ping
      */
     private checkMcpStatus;
+    /**
+     * Check MCP status and return structured data.
+     */
+    private checkMcpStatusData;
+    /**
+     * Collect all status data into a structured object for JSON output.
+     */
+    private collectStatusData;
+    /**
+     * Output status data as JSON.
+     */
+    private outputJsonStatus;
+    /**
+     * Original text format output.
+     */
+    private runTextFormat;
 }

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

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
 import { getErrorMessage } from '../../utils/error-helpers.js';
 import { FileInstanceDiscovery } from '../instance/file-instance-discovery.js';
+import { HeadlessTerminal } from '../terminal/headless-terminal.js';
 import { SocketIOTransportClient } from '../transport/socket-io-transport-client.js';
 export class StatusUseCase {
     contextTreeService;
@@ -22,7 +23,190 @@ export class StatusUseCase {
         this.trackingService = options.trackingService;
     }
     async run(options) {
-        this.terminal.log(`CLI Version: ${options.cliVersion}`);
+        const format = options.format ?? 'text';
+        if (format === 'json') {
+            const statusData = await this.collectStatusData(options.cliVersion);
+            this.outputJsonStatus(statusData);
+            return;
+        }
+        // Text format output (original behavior)
+        await this.runTextFormat(options.cliVersion);
+    }
+    /**
+     * Checks the MCP connection status by:
+     * 1. Discovering running brv instance
+     * 2. Connecting to it via Socket.IO
+     * 3. Verifying bidirectional communication with ping
+     */
+    async checkMcpStatus() {
+        try {
+            // Step 1: Discover running instance
+            const discoveryResult = await this.instanceDiscovery.discover(process.cwd());
+            if (!discoveryResult.found) {
+                if (discoveryResult.reason === 'instance_crashed') {
+                    this.terminal.log(`MCP Status: ${chalk.red('Instance crashed')} (stale instance file found)`);
+                }
+                else {
+                    this.terminal.log(`MCP Status: ${chalk.yellow('No instance running')}`);
+                }
+                return;
+            }
+            const { instance, projectRoot } = discoveryResult;
+            this.terminal.log(`MCP Status: Instance found (PID: ${instance.pid}, Port: ${instance.port})`);
+            // Step 2: Connect to instance
+            const client = new SocketIOTransportClient();
+            const url = instance.getTransportUrl();
+            try {
+                await client.connect(url);
+            }
+            catch (connectError) {
+                this.terminal.log(`MCP Status: ${chalk.red('Connection failed')} - ${getErrorMessage(connectError)}`);
+                return;
+            }
+            // Step 3: Verify bidirectional communication with ping
+            const isResponsive = await client.isConnected(2000);
+            if (isResponsive) {
+                this.terminal.log(`MCP Status: ${chalk.green('Connected and responsive')} (${projectRoot})`);
+            }
+            else {
+                this.terminal.log(`MCP Status: ${chalk.yellow('Connected but not responsive')} (ping timeout)`);
+            }
+            // Clean up
+            await client.disconnect();
+        }
+        catch (error) {
+            this.terminal.log(`MCP Status: ${chalk.red('Error checking status')}`);
+            this.terminal.warn(`Warning: ${getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Check MCP status and return structured data.
+     */
+    async checkMcpStatusData() {
+        try {
+            const discoveryResult = await this.instanceDiscovery.discover(process.cwd());
+            if (!discoveryResult.found) {
+                return discoveryResult.reason === 'instance_crashed' ? 'crashed' : 'no_instance';
+            }
+            const { instance } = discoveryResult;
+            const client = new SocketIOTransportClient();
+            const url = instance.getTransportUrl();
+            try {
+                await client.connect(url);
+                const isResponsive = await client.isConnected(2000);
+                await client.disconnect();
+                return isResponsive ? 'connected' : 'not_responsive';
+            }
+            catch {
+                return 'error';
+            }
+        }
+        catch {
+            return 'error';
+        }
+    }
+    /**
+     * Collect all status data into a structured object for JSON output.
+     */
+    async collectStatusData(cliVersion) {
+        const statusData = {
+            authStatus: 'unknown',
+            cliVersion,
+            contextTreeStatus: 'unknown',
+            currentDirectory: process.cwd(),
+            mcpStatus: 'no_instance',
+            projectInitialized: false,
+        };
+        // Auth status
+        try {
+            const token = await this.tokenStore.load();
+            if (token !== undefined && token.isValid()) {
+                statusData.authStatus = 'logged_in';
+                statusData.userEmail = token.userEmail;
+            }
+            else if (token === undefined) {
+                statusData.authStatus = 'not_logged_in';
+            }
+            else {
+                statusData.authStatus = 'expired';
+            }
+        }
+        catch {
+            statusData.authStatus = 'unknown';
+        }
+        // Project status
+        try {
+            const isInitialized = await this.projectConfigStore.exists();
+            statusData.projectInitialized = isInitialized;
+            if (isInitialized) {
+                const config = await this.projectConfigStore.read();
+                if (config) {
+                    statusData.teamName = config.teamName;
+                    statusData.spaceName = config.spaceName;
+                }
+            }
+        }
+        catch {
+            statusData.projectInitialized = false;
+        }
+        // MCP status
+        statusData.mcpStatus = await this.checkMcpStatusData();
+        // Context tree status
+        try {
+            const contextTreeExists = await this.contextTreeService.exists();
+            if (contextTreeExists) {
+                const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot();
+                if (!hasSnapshot) {
+                    await this.contextTreeSnapshotService.initEmptySnapshot();
+                }
+                const changes = await this.contextTreeSnapshotService.getChanges();
+                const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+                if (hasChanges) {
+                    statusData.contextTreeStatus = 'has_changes';
+                    statusData.contextTreeChanges = {
+                        added: changes.added,
+                        deleted: changes.deleted,
+                        modified: changes.modified,
+                    };
+                }
+                else {
+                    statusData.contextTreeStatus = 'no_changes';
+                }
+            }
+            else {
+                statusData.contextTreeStatus = 'not_initialized';
+            }
+        }
+        catch {
+            statusData.contextTreeStatus = 'unknown';
+        }
+        await this.trackingService.track('mem:status');
+        return statusData;
+    }
+    /**
+     * Output status data as JSON.
+     */
+    outputJsonStatus(statusData) {
+        const response = {
+            command: 'status',
+            data: statusData,
+            success: true,
+            timestamp: new Date().toISOString(),
+        };
+        // Write directly to stdout for clean JSON output
+        if (this.terminal instanceof HeadlessTerminal) {
+            this.terminal.writeFinalResponse(response);
+        }
+        else {
+            // Fallback for non-headless terminal
+            this.terminal.log(JSON.stringify(response));
+        }
+    }
+    /**
+     * Original text format output.
+     */
+    async runTextFormat(cliVersion) {
+        this.terminal.log(`CLI Version: ${cliVersion}`);
         try {
             const token = await this.tokenStore.load();
             if (token !== undefined && token.isValid()) {
@@ -100,51 +284,4 @@ export class StatusUseCase {
             this.terminal.warn(`Warning: ${error instanceof Error ? error.message : 'Context Tree unable to check status'}`);
         }
     }
-    /**
-     * Checks the MCP connection status by:
-     * 1. Discovering running brv instance
-     * 2. Connecting to it via Socket.IO
-     * 3. Verifying bidirectional communication with ping
-     */
-    async checkMcpStatus() {
-        try {
-            // Step 1: Discover running instance
-            const discoveryResult = await this.instanceDiscovery.discover(process.cwd());
-            if (!discoveryResult.found) {
-                if (discoveryResult.reason === 'instance_crashed') {
-                    this.terminal.log(`MCP Status: ${chalk.red('Instance crashed')} (stale instance file found)`);
-                }
-                else {
-                    this.terminal.log(`MCP Status: ${chalk.yellow('No instance running')}`);
-                }
-                return;
-            }
-            const { instance, projectRoot } = discoveryResult;
-            this.terminal.log(`MCP Status: Instance found (PID: ${instance.pid}, Port: ${instance.port})`);
-            // Step 2: Connect to instance
-            const client = new SocketIOTransportClient();
-            const url = instance.getTransportUrl();
-            try {
-                await client.connect(url);
-            }
-            catch (connectError) {
-                this.terminal.log(`MCP Status: ${chalk.red('Connection failed')} - ${getErrorMessage(connectError)}`);
-                return;
-            }
-            // Step 3: Verify bidirectional communication with ping
-            const isResponsive = await client.isConnected(2000);
-            if (isResponsive) {
-                this.terminal.log(`MCP Status: ${chalk.green('Connected and responsive')} (${projectRoot})`);
-            }
-            else {
-                this.terminal.log(`MCP Status: ${chalk.yellow('Connected but not responsive')} (ping timeout)`);
-            }
-            // Clean up
-            await client.disconnect();
-        }
-        catch (error) {
-            this.terminal.log(`MCP Status: ${chalk.red('Error checking status')}`);
-            this.terminal.warn(`Warning: ${getErrorMessage(error)}`);
-        }
-    }
 }

package/dist/infra/user/http-user-service.d.ts

@@ -7,6 +7,6 @@ export type UserServiceConfig = {
 export declare class HttpUserService implements IUserService {
     private readonly config;
     constructor(config: UserServiceConfig);
-    getCurrentUser(accessToken: string, sessionKey: string): Promise<User>;
+    getCurrentUser(sessionKey: string): Promise<User>;
     private mapToUser;
 }

package/dist/infra/user/http-user-service.js

@@ -8,9 +8,9 @@ export class HttpUserService {
             timeout: config.timeout ?? 10_000, // Default 10 seconds timeout
         };
     }
-    async getCurrentUser(accessToken, sessionKey) {
+    async getCurrentUser(sessionKey) {
         // IMPORTANT: Do not try-catch here - let callers handle errors (e.g., distinguish 401 from network errors)
-        const httpClient = new AuthenticatedHttpClient(accessToken, sessionKey);
+        const httpClient = new AuthenticatedHttpClient(sessionKey);
         const response = await httpClient.get(`${this.config.apiBaseUrl}/user/me`, {
             timeout: this.config.timeout,
         });

package/dist/oclif/commands/curate.d.ts

@@ -9,7 +9,12 @@ export default class Curate extends Command {
     static flags: {
         verbose?: import("@oclif/core/interfaces").BooleanFlag<boolean> | undefined;
         files: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        headless: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    protected createUseCase(): ICurateUseCase;
+    protected createUseCase(options: {
+        format: 'json' | 'text';
+        headless: boolean;
+    }): ICurateUseCase;
     run(): Promise<void>;
 }

package/dist/oclif/commands/curate.js

@@ -2,6 +2,7 @@ import { Args, Command, Flags } from '@oclif/core';
 import { isDevelopment } from '../../config/environment.js';
 import { FileGlobalConfigStore } from '../../infra/storage/file-global-config-store.js';
 import { createTokenStore } from '../../infra/storage/token-store.js';
+import { HeadlessTerminal } from '../../infra/terminal/headless-terminal.js';
 import { OclifTerminal } from '../../infra/terminal/oclif-terminal.js';
 import { MixpanelTrackingService } from '../../infra/tracking/mixpanel-tracking-service.js';
 import { CurateUseCase } from '../../infra/usecase/curate-use-case.js';
@@ -38,6 +39,15 @@ Bad examples:
             description: 'Include specific file paths for critical context (max 5 files)',
             multiple: true,
         }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+        headless: Flags.boolean({
+            default: false,
+            description: 'Run in headless mode (no TTY required, suitable for automation)',
+        }),
         ...(isDevelopment()
             ? {
                 verbose: Flags.boolean({
@@ -48,16 +58,27 @@ Bad examples:
             }
             : {}),
     };
-    createUseCase() {
+    createUseCase(options) {
         const tokenStore = createTokenStore();
         const globalConfigStore = new FileGlobalConfigStore();
-        const terminal = new OclifTerminal(this);
         const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
+        // Use HeadlessTerminal for headless mode or JSON format
+        const terminal = options.headless || options.format === 'json'
+            ? new HeadlessTerminal({ failOnPrompt: true, outputFormat: options.format })
+            : new OclifTerminal(this);
         return new CurateUseCase({ terminal, trackingService });
     }
     async run() {
         const { args, flags: rawFlags } = await this.parse(Curate);
         const flags = rawFlags;
-        return this.createUseCase().run({ context: args.context, files: flags.files, verbose: flags.verbose });
+        const format = (flags.format ?? 'text');
+        const headless = flags.headless ?? false;
+        return this.createUseCase({ format, headless }).run({
+            context: args.context,
+            files: flags.files,
+            format,
+            headless,
+            verbose: flags.verbose,
+        });
     }
 }