byterover-cli 2.5.2 → 3.0.0

package/dist/oclif/commands/providers/connect.js

@@ -1,24 +1,27 @@
+import { input, password, select, Separator } from '@inquirer/prompts';
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { OAUTH_CALLBACK_TIMEOUT_MS } from '../../../shared/constants/oauth.js';
-import { ModelEvents } from '../../../shared/transport/events/model-events.js';
+import { ModelEvents, } from '../../../shared/transport/events/model-events.js';
 import { ProviderEvents, } from '../../../shared/transport/events/provider-events.js';
 import { withDaemonRetry } from '../../lib/daemon-client.js';
 import { writeJsonResponse } from '../../lib/json-response.js';
+import { createEscapeSignal, isEscBack, isPromptCancelled, validateUrl, wizardSelectTheme, } from '../../lib/prompt-utils.js';
+import { createSpinner } from '../../lib/spinner.js';
 export default class ProviderConnect extends Command {
     static args = {
         provider: Args.string({
-            description: 'Provider ID to connect (e.g., anthropic, openai, openrouter)',
-            required: true,
+            description: 'Provider ID to connect (e.g., anthropic, openai, openrouter). Omit for interactive selection.',
+            required: false,
         }),
     };
     static description = 'Connect or switch to an LLM provider';
     static examples = [
+        '<%= config.bin %> providers connect',
         '<%= config.bin %> providers connect anthropic --api-key sk-xxx',
-        '<%= config.bin %> providers connect openai --api-key sk-xxx --model gpt-4.1',
         '<%= config.bin %> providers connect openai --oauth',
         '<%= config.bin %> providers connect byterover',
-        '<%= config.bin %> providers connect openai-compatible --base-url http://localhost:11434/v1',
-        '<%= config.bin %> providers connect openai-compatible --base-url http://localhost:11434/v1 --api-key sk-xxx --model llama3',
+        '<%= config.bin %> providers connect openai-compatible --base-url http://localhost:11434/v1 --api-key sk-xxx',
     ];
     static flags = {
         'api-key': Flags.string({
@@ -64,15 +67,9 @@ export default class ProviderConnect extends Command {
                         '\nExample: brv providers connect openai-compatible --base-url http://localhost:11434/v1');
                 }
                 if (baseUrl) {
-                    let parsed;
-                    try {
-                        parsed = new URL(baseUrl);
-                    }
-                    catch {
-                        throw new Error(`Invalid base URL format: "${baseUrl}". Must be a valid http:// or https:// URL.`);
-                    }
-                    if (!['http:', 'https:'].includes(parsed.protocol)) {
-                        throw new Error('URL must start with http:// or https://');
+                    const validationResult = validateUrl(baseUrl);
+                    if (typeof validationResult === 'string') {
+                        throw new TypeError(validationResult);
                     }
                 }
             }
@@ -104,7 +101,6 @@ export default class ProviderConnect extends Command {
     }
     async connectProviderOAuth({ code, providerId }, options, onProgress) {
         return withDaemonRetry(async (client) => {
-            // 1. Verify provider exists and supports OAuth
             const { providers } = await client.requestWithAck(ProviderEvents.LIST);
             const provider = providers.find((p) => p.id === providerId);
             if (!provider) {
@@ -113,13 +109,10 @@ export default class ProviderConnect extends Command {
             if (!provider.supportsOAuth) {
                 throw new Error(`Provider "${providerId}" does not support OAuth. Use --api-key instead.`);
             }
-            // --code is only valid for code-paste providers (e.g., Anthropic).
-            // Browser-callback providers like OpenAI handle the code exchange automatically.
             if (code && provider.oauthCallbackMode !== 'code-paste') {
                 throw new Error(`Provider "${providerId}" uses browser-based OAuth and does not accept --code.\n` +
                     `Run: brv providers connect ${providerId} --oauth`);
             }
-            // If --code is provided, submit it directly (code-paste providers)
             if (code) {
                 const response = await client.requestWithAck(ProviderEvents.SUBMIT_OAUTH_CODE, { code, providerId });
                 if (!response.success) {
@@ -127,16 +120,13 @@ export default class ProviderConnect extends Command {
                 }
                 return { providerName: provider.name, showInstructions: false };
             }
-            // 2. Start OAuth flow — returns immediately with auth URL
             const startResponse = await client.requestWithAck(ProviderEvents.START_OAUTH, {
                 providerId,
             });
             if (!startResponse.success) {
                 throw new Error(startResponse.error ?? 'Failed to start OAuth flow');
             }
-            // Always print auth URL (user's machine may not support browser launch)
             onProgress?.(`\nOpen this URL to authenticate:\n  ${startResponse.authUrl}\n`);
-            // 3. Handle based on callback mode
             if (startResponse.callbackMode === 'auto') {
                 onProgress?.('Waiting for authentication in browser...');
                 const awaitResponse = await client.requestWithAck(ProviderEvents.AWAIT_OAUTH_CALLBACK, { providerId }, { timeout: OAUTH_CALLBACK_TIMEOUT_MS });
@@ -145,20 +135,230 @@ export default class ProviderConnect extends Command {
                 }
                 return { providerName: provider.name, showInstructions: false };
             }
-            // code-paste mode: print instructions and exit
             onProgress?.('Copy the authorization code from the browser and run:');
             onProgress?.(`  brv providers connect ${providerId} --oauth --code <code>`);
             return { providerName: provider.name, showInstructions: true };
         }, options);
     }
+    async disconnectProvider(providerId, options) {
+        await withDaemonRetry(async (client) => {
+            await client.requestWithAck(ProviderEvents.DISCONNECT, { providerId });
+        }, options);
+    }
+    async fetchModels(providerId, options) {
+        return withDaemonRetry(async (client) => client.requestWithAck(ModelEvents.LIST, { providerId }), options);
+    }
+    async fetchProviders(options) {
+        const { providers } = await withDaemonRetry(async (client) => client.requestWithAck(ProviderEvents.LIST), options);
+        return providers;
+    }
+    // All prompt methods emit a blank line before rendering for visual spacing between wizard steps.
+    async promptForApiKey(providerName, apiKeyUrl, signal) {
+        this.log();
+        const hint = apiKeyUrl ? ` (get one at ${apiKeyUrl}):` : ':';
+        return password({
+            mask: true,
+            message: `Enter API key for ${providerName}${chalk.dim(hint)}`,
+        }, { signal });
+    }
+    async promptForAuthMethod(provider, signal) {
+        this.log();
+        const oauthLabel = provider.oauthLabel ?? 'OAuth (browser-based)';
+        return select({
+            choices: [
+                {
+                    name: `API Key${provider.apiKeyUrl ? ` — get one at ${provider.apiKeyUrl}` : ''}`,
+                    value: 'api-key',
+                },
+                { name: oauthLabel, value: 'oauth' },
+            ],
+            message: `How do you want to authenticate with ${provider.name}?`,
+            theme: wizardSelectTheme,
+        }, { signal });
+    }
+    async promptForBaseUrl(signal) {
+        this.log();
+        return input({
+            message: `Enter base URL ${chalk.dim('(e.g. http://localhost:11434/v1):')}`,
+            required: true,
+            validate: validateUrl,
+        }, { signal });
+    }
+    async promptForConnectedAction(provider, signal) {
+        this.log();
+        const choices = [];
+        if (!provider.isCurrent) {
+            choices.push({ name: 'Set as active', value: 'activate' });
+        }
+        if (provider.isConnected) {
+            choices.push({ name: 'Disconnect', value: 'disconnect' });
+        }
+        if (provider.requiresApiKey || provider.supportsOAuth) {
+            choices.push({ name: `Reconfigure ${provider.authMethod === 'oauth' ? 'OAuth' : 'API key'}`, value: 'reconfigure' });
+        }
+        return select({
+            choices,
+            message: `${provider.name} is already connected. What would you like to do?`,
+            theme: wizardSelectTheme,
+        }, { signal });
+    }
+    async promptForModel(models, signal) {
+        this.log();
+        if (models.length === 0) {
+            this.log(chalk.dim('No models available. Check your API key or provider configuration.'));
+            // Trigger back-navigation to auth step by throwing cancel
+            const error = new Error('No models available');
+            error.name = 'AbortPromptError';
+            throw error;
+        }
+        return select({
+            choices: [{ name: 'Skip (use default)', value: '' }, ...models.map((m) => ({ name: m.name, value: m.id }))],
+            loop: false,
+            message: 'Select a model',
+            theme: wizardSelectTheme,
+        }, { signal }).then((v) => v || undefined);
+    }
+    async promptForOptionalApiKey(providerName, signal) {
+        this.log();
+        const value = await input({ message: `Enter API key for ${providerName} ${chalk.dim('(optional, press Enter to skip):')}` }, { signal });
+        return value.trim() || undefined;
+    }
+    async promptForProvider(providers, signal) {
+        this.log();
+        const nameMaxChars = Math.max(...providers.map((p) => p.name.length));
+        const popular = providers.filter((p) => p.category === 'popular');
+        const other = providers.filter((p) => p.category === 'other');
+        const formatChoice = (p) => ({
+            name: `${p.name.padEnd(nameMaxChars + 3)} ${p.description}`,
+            value: p.id,
+        });
+        return select({
+            choices: [
+                new Separator('---------- Popular ----------'),
+                ...popular.map((p) => formatChoice(p)),
+                new Separator('\n---------- Others ----------'),
+                ...other.map((p) => formatChoice(p)),
+            ],
+            loop: false,
+            message: 'Select a provider',
+            theme: wizardSelectTheme,
+        }, { signal });
+    }
     async run() {
         const { args, flags } = await this.parse(ProviderConnect);
         const providerId = args.provider;
-        const apiKey = flags['api-key'];
-        const baseUrl = flags['base-url'];
-        const { code, model, oauth } = flags;
         const format = flags.format === 'json' ? 'json' : 'text';
-        // Validate flag combinations
+        // Interactive mode: no provider arg
+        if (!providerId) {
+            if (format === 'json') {
+                writeJsonResponse({
+                    command: 'providers connect',
+                    data: { error: 'Provider argument is required for JSON output' },
+                    success: false,
+                });
+                return;
+            }
+            try {
+                await this.runInteractive();
+            }
+            catch (error) {
+                this.log(error instanceof Error
+                    ? error.message
+                    : 'An unexpected error occurred while connecting the provider. Please try again.');
+            }
+            return;
+        }
+        // Non-interactive mode: provider arg provided
+        await this.runNonInteractive(providerId, {
+            apiKey: flags['api-key'],
+            baseUrl: flags['base-url'],
+            code: flags.code,
+            model: flags.model,
+            oauth: flags.oauth,
+        }, format);
+    }
+    /**
+     * Interactive flow with cancel-to-go-back navigation.
+     * Step 1 (provider) ← Step 2 (auth) ← Step 3 (model)
+     */
+    async runInteractive() {
+        const esc = createEscapeSignal();
+        const STEPS = ['provider', 'auth', 'model'];
+        let stepIndex = 0;
+        let providers = await this.fetchProviders();
+        let providerId;
+        let provider;
+        try {
+            /* eslint-disable no-await-in-loop -- intentional sequential interactive wizard */
+            while (stepIndex < STEPS.length) {
+                const currentStep = STEPS[stepIndex];
+                try {
+                    switch (currentStep) {
+                        case 'auth': {
+                            // If providerId or provider is not set, go back to provider step
+                            // eslint-disable-next-line max-depth
+                            if (!providerId || !provider) {
+                                stepIndex--;
+                                break;
+                            }
+                            const done = await this.runAuthStep(providerId, provider, esc.signal);
+                            // eslint-disable-next-line max-depth
+                            if (done) {
+                                stepIndex = STEPS.length; // skip remaining steps
+                            }
+                            break;
+                        }
+                        case 'model': {
+                            // If providerId is not set, go back to provider step
+                            // eslint-disable-next-line max-depth
+                            if (!providerId) {
+                                stepIndex = 0;
+                                break;
+                            }
+                            // ByteRover does not need model selection
+                            // eslint-disable-next-line max-depth
+                            if (providerId === 'byterover')
+                                break;
+                            await this.runModelStep(providerId, esc.signal);
+                            break;
+                        }
+                        case 'provider': {
+                            providerId = await this.promptForProvider(providers, esc.signal);
+                            provider = providers.find((p) => p.id === providerId);
+                            break;
+                        }
+                    }
+                    stepIndex++;
+                }
+                catch (error) {
+                    if (isEscBack(error)) {
+                        // Esc → go back one step
+                        if (stepIndex === 0)
+                            return;
+                        esc.reset();
+                        stepIndex--;
+                        // Re-fetch providers on back-navigation so isConnected states are fresh
+                        if (STEPS[stepIndex] === 'provider') {
+                            providers = await this.fetchProviders();
+                        }
+                    }
+                    else if (isPromptCancelled(error)) {
+                        // Ctrl+C → exit wizard
+                        return;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            /* eslint-enable no-await-in-loop */
+        }
+        finally {
+            esc.cleanup();
+        }
+    }
+    async runNonInteractive(providerId, flags, format) {
+        const { apiKey, baseUrl, code, model, oauth } = flags;
         if (oauth && apiKey) {
             const msg = 'Cannot use --oauth and --api-key together';
             if (format === 'json') {
@@ -215,4 +415,84 @@ export default class ProviderConnect extends Command {
             }
         }
     }
+    /* eslint-disable no-await-in-loop -- intentional retry loop for interactive auth */
+    /** Returns true when wizard should end (skip model step), false to continue to model step. */
+    async runAuthStep(providerId, provider, signal) {
+        // Provider already connected — ask what to do
+        if (provider.isConnected) {
+            const action = await this.promptForConnectedAction(provider, signal);
+            if (action === 'activate') {
+                const spinner = createSpinner('Connecting...');
+                const result = await this.connectProvider({ providerId });
+                spinner.clear();
+                this.log(`Connected to ${result.providerName} (${result.providerId})`);
+                return false;
+            }
+            if (action === 'disconnect') {
+                const spinner = createSpinner('Disconnecting...');
+                await this.disconnectProvider(providerId);
+                spinner.clear();
+                this.log(`Disconnected from ${provider.name}`);
+                return true;
+            }
+            // reconfigure → fall through to auth flow below
+        }
+        // No API key required (e.g., ByteRover free) but not openai-compatible — connect directly
+        if (!provider.requiresApiKey && !provider.supportsOAuth && providerId !== 'openai-compatible') {
+            const spinner = createSpinner('Connecting...');
+            const result = await this.connectProvider({ providerId });
+            spinner.clear();
+            this.log(`Connected to ${result.providerName} (${result.providerId})`);
+            return false;
+        }
+        // Retry loop — on connection failure, show error and re-prompt credentials
+        while (true) {
+            // Choose auth method if provider supports both
+            let authMethod = 'api-key';
+            if (provider.supportsOAuth && provider.requiresApiKey) {
+                authMethod = await this.promptForAuthMethod(provider, signal);
+            }
+            else if (provider.supportsOAuth) {
+                authMethod = 'oauth';
+            }
+            try {
+                if (authMethod === 'oauth') {
+                    const result = await this.connectProviderOAuth({ providerId }, undefined, (msg) => this.log(msg));
+                    if (!result.showInstructions) {
+                        this.log(`Connected to ${result.providerName} via OAuth`);
+                    }
+                    return false;
+                }
+                // API key flow
+                const isOpenAiCompatible = providerId === 'openai-compatible';
+                const baseUrl = isOpenAiCompatible ? await this.promptForBaseUrl(signal) : undefined;
+                const apiKey = isOpenAiCompatible
+                    ? await this.promptForOptionalApiKey(provider.name, signal)
+                    : await this.promptForApiKey(provider.name, provider.apiKeyUrl, signal);
+                const spinner = createSpinner('Connecting...');
+                const result = await this.connectProvider({ apiKey, baseUrl, providerId });
+                spinner.clear();
+                this.log(`Connected to ${result.providerName} (${result.providerId})`);
+                return false;
+            }
+            catch (error) {
+                // Prompt cancellation → propagate to state machine (go back to provider)
+                if (isPromptCancelled(error))
+                    throw error;
+                // Connection error → show message and retry auth
+                this.log(error instanceof Error ? error.message : 'Connection failed. Please try again.');
+            }
+        }
+    }
+    /* eslint-enable no-await-in-loop */
+    async runModelStep(providerId, signal) {
+        const spinner = createSpinner('Fetching models...');
+        const modelList = await this.fetchModels(providerId);
+        spinner.clear();
+        const modelId = await this.promptForModel(modelList.models, signal);
+        if (!modelId)
+            return;
+        await withDaemonRetry(async (client) => client.requestWithAck(ModelEvents.SET_ACTIVE, { modelId, providerId }));
+        this.log(`Model set to: ${modelId}`);
+    }
 }

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

@@ -8,4 +8,5 @@ export default class Pull extends Command {
     };
     run(): Promise<void>;
     private executePull;
+    private logVcHint;
 }

package/dist/oclif/commands/pull.js

@@ -38,6 +38,7 @@ Downloads the context tree from the ByteRover cloud to your local project.`;
                 }
                 else {
                     this.log(pullResult.summary);
+                    this.logVcHint();
                 }
                 return;
             }
@@ -50,6 +51,7 @@ Downloads the context tree from the ByteRover cloud to your local project.`;
                 this.log(`  Branch: ${branch}`);
                 this.log(`  Commit: ${result.commitSha.slice(0, 7)}`);
                 this.log(`  Added: ${result.added}, Edited: ${result.edited}, Deleted: ${result.deleted}`);
+                this.logVcHint();
             }
         }
         catch (error) {
@@ -59,6 +61,7 @@ Downloads the context tree from the ByteRover cloud to your local project.`;
             }
             else {
                 this.log(formatConnectionError(error));
+                this.logVcHint();
             }
         }
     }
@@ -72,4 +75,8 @@ Downloads the context tree from the ByteRover cloud to your local project.`;
             return { hasChanges: false, result };
         });
     }
+    logVcHint() {
+        this.log('\nTip: Version control is now available for your context tree.');
+        this.log('Learn more: https://docs.byterover.dev/git-semantic/overview');
+    }
 }

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

@@ -8,4 +8,5 @@ export default class Push extends Command {
     };
     run(): Promise<void>;
     private executePush;
+    private logVcHint;
 }

package/dist/oclif/commands/push.js

@@ -37,6 +37,7 @@ Uploads your local context tree changes to the ByteRover cloud.`;
                 }
                 else {
                     this.log('Push cancelled.');
+                    this.logVcHint();
                 }
                 return;
             }
@@ -46,6 +47,7 @@ Uploads your local context tree changes to the ByteRover cloud.`;
                 }
                 else {
                     this.log('No context changes to push.');
+                    this.logVcHint();
                 }
                 return;
             }
@@ -69,6 +71,7 @@ Uploads your local context tree changes to the ByteRover cloud.`;
                 this.log(`  Branch: ${branch}`);
                 this.log(`  Added: ${result.added}, Edited: ${result.edited}, Deleted: ${result.deleted}`);
                 this.log(`  View: ${result.url}`);
+                this.logVcHint();
             }
         }
         catch (error) {
@@ -78,6 +81,7 @@ Uploads your local context tree changes to the ByteRover cloud.`;
             }
             else {
                 this.log(formatConnectionError(error));
+                this.logVcHint();
             }
         }
     }
@@ -91,4 +95,8 @@ Uploads your local context tree changes to the ByteRover cloud.`;
             return { noChanges: false, result };
         });
     }
+    logVcHint() {
+        this.log('\nTip: Version control is now available for your context tree.');
+        this.log('Learn more: https://docs.byterover.dev/git-semantic/overview');
+    }
 }

package/dist/oclif/commands/review/approve.d.ts

@@ -0,0 +1,17 @@
+import type { ReviewDecideTaskResponse } from '../../../shared/transport/events/review-events.js';
+import { ReviewDecisionCommand } from './base-review-decision.js';
+type ReviewFile = ReviewDecideTaskResponse['files'][number];
+export default class ReviewApprove extends ReviewDecisionCommand {
+    static args: {
+        taskId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        file: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected readonly decision: "approved";
+    protected formatFileLine(file: ReviewFile): string;
+}
+export {};

package/dist/oclif/commands/review/approve.js

@@ -0,0 +1,37 @@
+import { Args, Flags } from '@oclif/core';
+import { ReviewDecisionCommand } from './base-review-decision.js';
+export default class ReviewApprove extends ReviewDecisionCommand {
+    static args = {
+        taskId: Args.string({
+            description: 'Task ID shown in the curate output (e.g. "brv review approve abc-123")',
+            required: true,
+        }),
+    };
+    static description = 'Approve pending review operations for a curate task';
+    static examples = [
+        '# Approve all pending changes from a curate task',
+        '<%= config.bin %> review approve abc-123',
+        '',
+        '# Approve specific files',
+        '<%= config.bin %> review approve abc-123 --file architecture/security/audit.md',
+        '<%= config.bin %> review approve abc-123 --file auth/jwt.md --file auth/oauth.md',
+        '',
+        '# Approve and get structured output (useful for coding agents)',
+        '<%= config.bin %> review approve abc-123 --format json',
+    ];
+    static flags = {
+        file: Flags.string({
+            description: 'Approve only the specified file path(s) (relative to context tree)',
+            multiple: true,
+        }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+    };
+    decision = 'approved';
+    formatFileLine(file) {
+        return `✓ Approved ${file.path}`;
+    }
+}

package/dist/oclif/commands/review/base-review-decision.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import { type ReviewDecideTaskResponse } from '../../../shared/transport/events/review-events.js';
+import { type DaemonClientOptions } from '../../lib/daemon-client.js';
+type ReviewFile = ReviewDecideTaskResponse['files'][number];
+export declare abstract class ReviewDecisionCommand extends Command {
+    static args: {
+        taskId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        file: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected abstract readonly decision: 'approved' | 'rejected';
+    protected abstract formatFileLine(file: ReviewFile): string;
+    protected getDaemonClientOptions(): DaemonClientOptions;
+    run(): Promise<void>;
+}
+export {};

package/dist/oclif/commands/review/base-review-decision.js

@@ -0,0 +1,71 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { ReviewEvents } from '../../../shared/transport/events/review-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+import { writeJsonResponse } from '../../lib/json-response.js';
+export class ReviewDecisionCommand extends Command {
+    static args = {
+        taskId: Args.string({
+            required: true,
+        }),
+    };
+    static flags = {
+        file: Flags.string({
+            multiple: true,
+        }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+    };
+    getDaemonClientOptions() {
+        return {};
+    }
+    async run() {
+        const ctor = this.constructor;
+        const { args, flags } = await this.parse({ args: ctor.args, flags: ctor.flags });
+        const format = flags.format === 'json' ? 'json' : 'text';
+        try {
+            const response = await withDaemonRetry((client) => client.requestWithAck(ReviewEvents.DECIDE_TASK, {
+                decision: this.decision,
+                ...(flags.file?.length ? { filePaths: flags.file } : {}),
+                taskId: args.taskId,
+            }), this.getDaemonClientOptions());
+            if (format === 'json') {
+                writeJsonResponse({
+                    command: 'review',
+                    data: {
+                        decision: this.decision,
+                        files: response.files,
+                        status: 'success',
+                        taskId: args.taskId,
+                        totalCount: response.totalCount,
+                    },
+                    success: true,
+                });
+            }
+            else {
+                if (response.totalCount === 0) {
+                    this.log(`No pending operations found for task ${args.taskId}.`);
+                    return;
+                }
+                for (const file of response.files) {
+                    this.log(this.formatFileLine(file));
+                }
+                this.log(`\n${response.totalCount} operation${response.totalCount === 1 ? '' : 's'} ${this.decision}.`);
+            }
+        }
+        catch (error) {
+            if (format === 'json') {
+                writeJsonResponse({
+                    command: 'review',
+                    data: { error: error instanceof Error ? error.message : 'Review failed', status: 'error' },
+                    success: false,
+                });
+            }
+            else {
+                this.log(formatConnectionError(error));
+            }
+        }
+    }
+}

package/dist/oclif/commands/review/pending.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+import { type DaemonClientOptions } from '../../lib/daemon-client.js';
+export default class ReviewPending extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getDaemonClientOptions(): DaemonClientOptions;
+    run(): Promise<void>;
+    private printTask;
+    private printText;
+}