byterover-cli 2.5.2 → 3.0.0

package/dist/oclif/commands/vc/remote/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class VcRemote extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/remote/index.js

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+import { VcEvents } from '../../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../../lib/daemon-client.js';
+export default class VcRemote extends Command {
+    static description = 'Show current remote origin';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.REMOTE, { subcommand: 'show' }));
+            this.log(result.url ? `origin: ${result.url}` : 'No remote configured.');
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/remote/set-url.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class VcRemoteSetUrl extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        url: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/vc/remote/set-url.js

@@ -0,0 +1,30 @@
+import { Args, Command } from '@oclif/core';
+import { getGitRemoteBaseUrl } from '../../../../server/config/environment.js';
+import { VcEvents } from '../../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../../lib/daemon-client.js';
+export default class VcRemoteSetUrl extends Command {
+    static args = {
+        name: Args.string({ description: 'Remote name', required: true }),
+        url: Args.string({
+            description: `Remote URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)`,
+            required: true,
+        }),
+    };
+    static description = 'Update a remote URL';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> origin ${getGitRemoteBaseUrl()}/acme/project.git`,
+    ];
+    async run() {
+        const { args } = await this.parse(VcRemoteSetUrl);
+        if (args.name !== 'origin') {
+            this.error(`Only 'origin' remote is currently supported.`);
+        }
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.REMOTE, { subcommand: 'set-url', url: args.url }));
+            this.log(`Remote 'origin' updated to ${result.url}.`);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+}

package/dist/oclif/commands/vc/reset.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class VcReset extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        hard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        soft: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+    private formatRefResult;
+    private formatUnstageResult;
+}

package/dist/oclif/commands/vc/reset.js

@@ -0,0 +1,62 @@
+import { Command, Flags } from '@oclif/core';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcReset extends Command {
+    static description = 'Unstage files or undo commits';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> notes.md',
+        '<%= config.bin %> <%= command.id %> --soft HEAD~1',
+        '<%= config.bin %> <%= command.id %> --hard HEAD~1',
+        '<%= config.bin %> <%= command.id %> --hard',
+    ];
+    static flags = {
+        hard: Flags.boolean({
+            description: 'Reset HEAD, index, and working tree',
+            exclusive: ['soft'],
+        }),
+        soft: Flags.boolean({
+            description: 'Reset HEAD only, keep changes staged',
+            exclusive: ['hard'],
+        }),
+    };
+    static strict = false;
+    async run() {
+        const { argv, flags } = await this.parse(VcReset);
+        const args = argv.filter((a) => typeof a === 'string');
+        // When --soft or --hard is set, first arg is the optional ref (default HEAD)
+        const mode = flags.soft ? 'soft' : flags.hard ? 'hard' : undefined;
+        const ref = mode ? args[0] : undefined;
+        const filePaths = mode ? undefined : args.length > 0 ? args : undefined;
+        try {
+            if (filePaths) {
+                const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.RESET, { filePaths }));
+                this.formatUnstageResult(result);
+            }
+            else if (mode) {
+                const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.RESET, { mode, ref }));
+                this.formatRefResult(result);
+            }
+            else {
+                const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.RESET, {}));
+                this.formatUnstageResult(result);
+            }
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+    formatRefResult(result) {
+        if (!result.headSha)
+            return; // Empty repo — silent no-op, matches git
+        this.log(`HEAD is now at ${result.headSha.slice(0, 7)}`);
+    }
+    formatUnstageResult(result) {
+        if (result.filesUnstaged === 0) {
+            this.log('Nothing to unstage.');
+        }
+        else {
+            this.log(`Unstaged ${result.filesUnstaged} file(s).`);
+        }
+    }
+}

package/dist/oclif/commands/vc/status.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class VcStatus extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private formatOutput;
+    private printChangeSections;
+}

package/dist/oclif/commands/vc/status.js

@@ -0,0 +1,106 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { formatConnectionError, withDaemonRetry } from '../../lib/daemon-client.js';
+export default class VcStatus extends Command {
+    static description = 'Show ByteRover version control status';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        try {
+            const result = await withDaemonRetry(async (client) => client.requestWithAck(VcEvents.STATUS, {}));
+            this.formatOutput(result);
+        }
+        catch (error) {
+            this.error(formatConnectionError(error));
+        }
+    }
+    formatOutput(result) {
+        if (!result.initialized) {
+            this.log(chalk.yellow('ByteRover version control not initialized — run `brv vc init` to initialize'));
+            return;
+        }
+        this.log(chalk.bold(`On branch ${result.branch ?? '(detached HEAD)'}`));
+        if (result.hasCommits === false) {
+            this.log(chalk.yellow('No commits yet'));
+        }
+        if (result.trackingBranch) {
+            const ahead = result.ahead ?? 0;
+            const behind = result.behind ?? 0;
+            if (ahead > 0 && behind > 0) {
+                this.log(`Your branch and '${result.trackingBranch}' have diverged,\n` +
+                    `and have ${ahead} and ${behind} different commits each, respectively.`);
+            }
+            else if (ahead > 0) {
+                this.log(`Your branch is ahead of '${result.trackingBranch}' by ${ahead} commit${ahead === 1 ? '' : 's'}.`);
+            }
+            else if (behind > 0) {
+                this.log(`Your branch is behind '${result.trackingBranch}' by ${behind} commit${behind === 1 ? '' : 's'}.`);
+            }
+        }
+        const { staged, unstaged, untracked } = result;
+        const hasChanges = staged.added.length > 0 ||
+            staged.modified.length > 0 ||
+            staged.deleted.length > 0 ||
+            unstaged.modified.length > 0 ||
+            unstaged.deleted.length > 0 ||
+            untracked.length > 0;
+        if (result.mergeInProgress) {
+            const hasUnmerged = result.unmerged && result.unmerged.length > 0;
+            if (hasUnmerged) {
+                this.log(chalk.yellow('You have unmerged paths.'));
+                this.log(chalk.yellow('  (fix conflicts and run "brv vc add", then "brv vc merge --continue")'));
+                this.log('');
+                this.log(chalk.bold('Unmerged paths:'));
+                for (const f of result.unmerged) {
+                    const label = f.type === 'deleted_modified' ? 'deleted by them' : f.type === 'both_added' ? 'both added' : 'both modified';
+                    this.log(chalk.red(`   ${label}:   ${f.path}`));
+                }
+            }
+            else {
+                this.log(chalk.yellow('All conflicts fixed but you are still merging.'));
+                this.log(chalk.yellow('  (use "brv vc merge --continue" to conclude merge)'));
+                if (!hasChanges)
+                    return;
+            }
+        }
+        else if (!hasChanges && !(result.conflictMarkerFiles && result.conflictMarkerFiles.length > 0)) {
+            this.log('Nothing to commit, working directory clean');
+            return;
+        }
+        if (result.conflictMarkerFiles && result.conflictMarkerFiles.length > 0) {
+            this.log(chalk.yellow('Files with conflict markers:'));
+            this.log(chalk.yellow('  (resolve conflicts and run "brv vc add" before pushing)'));
+            this.log('');
+            for (const f of result.conflictMarkerFiles) {
+                this.log(chalk.red(`   ${f} (conflict)`));
+            }
+        }
+        this.printChangeSections(result);
+    }
+    printChangeSections(result) {
+        const { staged, unstaged, untracked } = result;
+        if (staged.added.length > 0 || staged.modified.length > 0 || staged.deleted.length > 0) {
+            this.log(chalk.bold('Changes to be committed:'));
+            for (const f of staged.added)
+                this.log(chalk.green(`   new file:   ${f}`));
+            for (const f of staged.modified)
+                this.log(chalk.green(`   modified:   ${f}`));
+            for (const f of staged.deleted)
+                this.log(chalk.green(`   deleted:    ${f}`));
+        }
+        if (unstaged.modified.length > 0 || unstaged.deleted.length > 0) {
+            this.log(chalk.bold('Changes not staged for commit:'));
+            this.log(chalk.bold('(use "brv vc add ‹file>..." to include in what will be committed)'));
+            for (const f of unstaged.modified)
+                this.log(chalk.red(`   modified:   ${f}`));
+            for (const f of unstaged.deleted)
+                this.log(chalk.red(`   deleted:    ${f}`));
+        }
+        if (untracked.length > 0) {
+            this.log(chalk.bold('Untracked files:'));
+            this.log(chalk.bold('(use "brv vc add ‹file>..." to include in what will be committed)'));
+            for (const f of untracked)
+                this.log(chalk.red(`   ${f}`));
+        }
+    }
+}

package/dist/oclif/hooks/init/validate-brv-config.d.ts

@@ -0,0 +1,26 @@
+import type { Hook } from '@oclif/core';
+import type { IProjectConfigStore } from '../../../server/core/interfaces/storage/i-project-config-store.js';
+import { type AutoInitDeps } from '../../../server/infra/config/auto-init.js';
+/**
+ * Commands that should skip auto-init and config version validation.
+ */
+export declare const COMMANDS_NEED_AUTO_INIT: Set<string>;
+/**
+ * Core validation logic extracted for testability.
+ * Auto-initializes .brv/ if it doesn't exist (for non-vc commands), then migrates config version if needed.
+ * VC commands still require explicit `brv vc init`.
+ * Also ensures connector files are patched with `brv curate view` docs (once per project).
+ *
+ * @param commandId - The command being executed
+ * @param configStore - The config store to use for reading config
+ * @param argv - Command arguments (used to detect help flags)
+ * @param autoInitDeps - Dependencies for auto-init (optional, for testing)
+ */
+export declare const validateBrvConfigVersion: (commandId: string, configStore: IProjectConfigStore, argv?: string[], autoInitDeps?: AutoInitDeps) => Promise<void>;
+/**
+ * Init hook that ensures .brv/ exists and validates config version.
+ * Runs once during CLI bootstrap — does NOT re-fire for runCommand() calls,
+ * so commands like `init` can safely delegate to sub-commands.
+ */
+declare const hook: Hook<'init'>;
+export default hook;

package/dist/oclif/hooks/init/validate-brv-config.js

@@ -0,0 +1,62 @@
+import { BRV_CONFIG_VERSION } from '../../../server/constants.js';
+import { ensureProjectInitialized } from '../../../server/infra/config/auto-init.js';
+import { ProjectConfigStore } from '../../../server/infra/config/file-config-store.js';
+import { FileContextTreeService } from '../../../server/infra/context-tree/file-context-tree-service.js';
+import { syncConfigToXdg } from '../../../server/utils/config-xdg-sync.js';
+/**
+ * Commands that should skip auto-init and config version validation.
+ */
+export const COMMANDS_NEED_AUTO_INIT = new Set(['connectors:install', 'curate', 'hub:install', 'main', 'query']);
+const HELP_FLAGS = new Set(['--h', '--help', '-h', '-help']);
+/**
+ * Core validation logic extracted for testability.
+ * Auto-initializes .brv/ if it doesn't exist (for non-vc commands), then migrates config version if needed.
+ * VC commands still require explicit `brv vc init`.
+ * Also ensures connector files are patched with `brv curate view` docs (once per project).
+ *
+ * @param commandId - The command being executed
+ * @param configStore - The config store to use for reading config
+ * @param argv - Command arguments (used to detect help flags)
+ * @param autoInitDeps - Dependencies for auto-init (optional, for testing)
+ */
+export const validateBrvConfigVersion = async (commandId, configStore, argv = [], autoInitDeps) => {
+    if (argv.some((arg) => HELP_FLAGS.has(arg)))
+        return;
+    const exists = await configStore.exists();
+    if (!exists && COMMANDS_NEED_AUTO_INIT.has(commandId)) {
+        const deps = autoInitDeps ?? {
+            contextTreeService: new FileContextTreeService(),
+            projectConfigStore: configStore,
+        };
+        await ensureProjectInitialized(deps);
+        const config = await configStore.read();
+        if (!config) {
+            throw new Error('fatal: corrupt or unreadable config: .brv/config.json');
+        }
+        // ProjectConfigStore checks .brv/ at process.cwd() directly (no walk-up),
+        // so configStore.exists() returning true means process.cwd() IS the project root.
+        const cwd = process.cwd();
+        if (config.version !== BRV_CONFIG_VERSION) {
+            const updated = config.withVersion(BRV_CONFIG_VERSION);
+            await configStore.write(updated);
+            await syncConfigToXdg(updated, cwd);
+        }
+    }
+};
+/**
+ * Init hook that ensures .brv/ exists and validates config version.
+ * Runs once during CLI bootstrap — does NOT re-fire for runCommand() calls,
+ * so commands like `init` can safely delegate to sub-commands.
+ */
+const hook = async function (options) {
+    try {
+        await validateBrvConfigVersion(options.id ?? '', new ProjectConfigStore(), options.argv ?? []);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        process.exit(1);
+    }
+};
+export default hook;

package/dist/oclif/lib/daemon-client.d.ts

@@ -3,6 +3,8 @@ import { type TransportConnector } from '../../server/infra/transport/transport-
 export interface DaemonClientOptions {
     /** Max retry attempts. Default: 3 */
     maxRetries?: number;
+    /** Explicit project path — bypasses walk-up discovery. Use for `init` where .brv/ doesn't exist yet. */
+    projectPath?: string;
     /** Delay between retries in ms. Default: 2000. Set to 0 in tests. */
     retryDelayMs?: number;
     /** Optional transport connector for DI/testing */

package/dist/oclif/lib/daemon-client.js

@@ -2,6 +2,7 @@ import { ConnectionError, ConnectionFailedError, DaemonSpawnError, InstanceCrash
 import { TaskErrorCode } from '../../server/core/domain/errors/task-error.js';
 import { createDaemonAwareConnector } from '../../server/infra/transport/transport-connector.js';
 import { getSandboxEnvironmentName, isSandboxEnvironment, isSandboxNetworkError, } from '../../server/utils/sandbox-detector.js';
+import { VcErrorCode } from '../../shared/transport/events/vc-events.js';
 /** Max retry attempts when daemon disconnects mid-task */
 const MAX_RETRIES = 3;
 /** Delay between retry attempts (ms) */
@@ -18,6 +19,20 @@ const USER_FRIENDLY_MESSAGES = {
     [TaskErrorCode.PROVIDER_NOT_CONFIGURED]: 'No provider connected. Run "brv providers connect byterover" to use the free built-in provider, or connect another provider.',
     [TaskErrorCode.SPACE_NOT_CONFIGURED]: 'No space configured. Run "brv space list" to see available spaces, then "brv space switch --team <team> --name <space>" to select one.',
     [TaskErrorCode.SPACE_NOT_FOUND]: 'Space not found. Check your configuration.',
+    [TaskErrorCode.VC_GIT_INITIALIZED]: 'ByteRover version control is active. Use brv vc commands instead of legacy sync commands.',
+    [VcErrorCode.AUTH_FAILED]: 'Authentication failed. Run brv login.',
+    [VcErrorCode.CONFIG_KEY_NOT_SET]: 'Config key is not set.',
+    [VcErrorCode.CONFLICT_MARKERS_PRESENT]: 'Conflict markers detected. Resolve conflicts and run brv vc add before pushing.',
+    [VcErrorCode.GIT_NOT_INITIALIZED]: 'ByteRover version control not initialized. Run brv vc init first.',
+    // INVALID_BRANCH_NAME intentionally omitted: fall through to server's message with actual branch name
+    [VcErrorCode.INVALID_CONFIG_KEY]: 'Invalid config key. Allowed: user.name, user.email.',
+    [VcErrorCode.NETWORK_ERROR]: 'Network error. Check your connection and try again.',
+    [VcErrorCode.NON_FAST_FORWARD]: 'Remote has changes. Run brv vc pull first.',
+    [VcErrorCode.NOTHING_STAGED]: 'Nothing staged. Run brv vc add first.',
+    [VcErrorCode.NOTHING_TO_PUSH]: 'No commits to push. Run brv vc add and brv vc commit first.',
+    [VcErrorCode.REMOTE_ALREADY_EXISTS]: "Remote 'origin' already exists. Use brv vc remote set-url <url> to update.",
+    // UNCOMMITTED_CHANGES intentionally omitted: fall through to server's detailed message with file paths
+    // USER_NOT_CONFIGURED intentionally omitted: fall through to server's specific hint with actual values
 };
 /**
  * Connects to the daemon, auto-starting it if needed.
@@ -35,7 +50,7 @@ export async function connectToDaemonClient(options) {
 export async function withDaemonRetry(fn, options) {
     const maxRetries = options?.maxRetries ?? MAX_RETRIES;
     const retryDelayMs = options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
-    const connector = options?.transportConnector ?? createDaemonAwareConnector();
+    const connector = options?.transportConnector ?? createDaemonAwareConnector(options?.projectPath);
     let lastError;
     /* eslint-disable no-await-in-loop -- intentional sequential retry loop */
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -132,21 +147,32 @@ export function formatConnectionError(error, providerContext) {
         }
         return baseMessage;
     }
+    // Task errors (from task-client.ts waitForTaskCompletion) arrive as plain Error with .code property.
+    // Check code-based lookup before text-matching — mirrors TUI's formatTaskError behavior.
+    if (error instanceof Error && 'code' in error) {
+        const { code } = error;
+        if (typeof code === 'string') {
+            return USER_FRIENDLY_MESSAGES[code] ?? error.message;
+        }
+    }
     const message = error instanceof Error ? error.message : String(error);
     const lowerMessage = message.toLowerCase();
     if (lowerMessage.includes('401') || lowerMessage.includes('unauthorized')) {
         return "Authentication required for cloud sync. Run 'brv login' to connect your account.";
     }
     if (lowerMessage.includes('api key') || lowerMessage.includes('invalid key')) {
-        const provider = providerContext?.activeProvider ?? '<provider>';
-        const model = providerContext?.activeModel;
-        const currentInfo = model ? `Provider: ${provider}  Model: ${model}\n\n` : `Provider: ${provider}\n\n`;
-        return (`LLM provider credentials are missing or invalid.\n${currentInfo}` +
-            '  Reconnect your provider:\n' +
-            `    brv providers connect ${provider}\n\n` +
-            '  Switch to a different provider:\n' +
-            '    brv providers switch <provider>\n\n' +
-            '  See all options:  brv providers --help');
+        return formatApiKeyError(providerContext);
     }
     return `Unexpected error: ${message}`;
 }
+function formatApiKeyError(providerContext) {
+    const provider = providerContext?.activeProvider ?? '<provider>';
+    const model = providerContext?.activeModel;
+    const currentInfo = model ? `Provider: ${provider}  Model: ${model}\n\n` : `Provider: ${provider}\n\n`;
+    return (`LLM provider API key is missing or invalid.\n${currentInfo}` +
+        '  Reconnect with your API key:\n' +
+        `    brv providers connect ${provider} --api-key <key>\n\n` +
+        '  Switch to a different provider:\n' +
+        '    brv providers switch <provider>\n\n' +
+        '  See all options:  brv providers --help');
+}

package/dist/oclif/lib/prompt-utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared theme for select prompts in interactive wizards.
+ * Appends "esc back" to the built-in key help tip (↑↓ navigate • ⏎ select).
+ */
+export declare const wizardSelectTheme: {
+    style: {
+        keysHelpTip: (keys: [string, string][]) => string;
+    };
+};
+/**
+ * Shared theme for input/password prompts in interactive wizards.
+ * Appends "esc back" hint to the message line.
+ */
+export declare const wizardInputTheme: {
+    style: {
+        message(text: string, status: string): string;
+    };
+};
+/** Esc key — go back to previous step */
+export declare function isEscBack(error: unknown): boolean;
+/** Ctrl+C — exit the wizard entirely */
+export declare function isForceExit(error: unknown): boolean;
+/** Any prompt cancellation (Esc or Ctrl+C) */
+export declare function isPromptCancelled(error: unknown): boolean;
+/**
+ * Validates a URL string.
+ * @param value The URL string to validate.
+ * @returns True if the URL is valid, otherwise an error message.
+ */
+export declare function validateUrl(value: string): boolean | string;
+/**
+ * Creates an AbortSignal that aborts when Escape is pressed.
+ * Use with @inquirer/prompts to enable Esc-to-go-back in interactive wizards.
+ *
+ * - `signal` — pass to prompt's context `{signal}` to make it cancellable
+ * - `reset()` — create a fresh AbortController after a cancel (signal is single-use)
+ * - `cleanup()` — remove the keypress listener when the wizard is done
+ */
+export declare function createEscapeSignal(): {
+    cleanup: () => void;
+    reset: () => void;
+    signal: AbortSignal;
+};

package/dist/oclif/lib/prompt-utils.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+/**
+ * Shared theme for select prompts in interactive wizards.
+ * Appends "esc back" to the built-in key help tip (↑↓ navigate • ⏎ select).
+ */
+export const wizardSelectTheme = {
+    style: {
+        keysHelpTip: (keys) => [...keys, ['esc', 'cancel']].map(([key, action]) => `${key} ${chalk.dim(action)}`).join(chalk.dim(' • ')),
+    },
+};
+/**
+ * Shared theme for input/password prompts in interactive wizards.
+ * Appends "esc back" hint to the message line.
+ */
+export const wizardInputTheme = {
+    style: {
+        message(text, status) {
+            const base = chalk.bold(text);
+            return status === 'done' ? base : `${chalk.bold(text)} ${chalk.dim('(esc back)')}`;
+        },
+    },
+};
+/** Esc key — go back to previous step */
+export function isEscBack(error) {
+    // @inquirer/prompts error class names as of v7
+    return error instanceof Error && error.name === 'AbortPromptError';
+}
+/** Ctrl+C — exit the wizard entirely */
+export function isForceExit(error) {
+    // @inquirer/prompts error class names as of v7
+    return error instanceof Error && (error.name === 'ExitPromptError' || error.name === 'CancelPromptError');
+}
+/** Any prompt cancellation (Esc or Ctrl+C) */
+export function isPromptCancelled(error) {
+    return isEscBack(error) || isForceExit(error);
+}
+/**
+ * Validates a URL string.
+ * @param value The URL string to validate.
+ * @returns True if the URL is valid, otherwise an error message.
+ */
+export function validateUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return `Invalid base URL format: "${value}". Must be a valid http:// or https:// URL.`;
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+        return 'URL must start with http:// or https://';
+    }
+    return true;
+}
+/**
+ * Creates an AbortSignal that aborts when Escape is pressed.
+ * Use with @inquirer/prompts to enable Esc-to-go-back in interactive wizards.
+ *
+ * - `signal` — pass to prompt's context `{signal}` to make it cancellable
+ * - `reset()` — create a fresh AbortController after a cancel (signal is single-use)
+ * - `cleanup()` — remove the keypress listener when the wizard is done
+ */
+export function createEscapeSignal() {
+    let controller = new AbortController();
+    const onKeypress = (_ch, key) => {
+        if (key?.name === 'escape') {
+            controller.abort();
+        }
+    };
+    if (process.stdin.isTTY) {
+        process.stdin.on('keypress', onKeypress);
+    }
+    return {
+        cleanup() {
+            process.stdin.removeListener('keypress', onKeypress);
+        },
+        reset() {
+            controller = new AbortController();
+        },
+        get signal() {
+            return controller.signal;
+        },
+    };
+}

package/dist/oclif/lib/spinner.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Minimal stderr spinner that erases itself when cleared.
+ * Shows a spinning animation with a message, disappears completely on clear().
+ * No-op in non-TTY environments (CI, pipes).
+ */
+export declare function createSpinner(message: string): {
+    clear: () => void;
+};

package/dist/oclif/lib/spinner.js

@@ -0,0 +1,23 @@
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Minimal stderr spinner that erases itself when cleared.
+ * Shows a spinning animation with a message, disappears completely on clear().
+ * No-op in non-TTY environments (CI, pipes).
+ */
+export function createSpinner(message) {
+    if (!process.stderr.isTTY) {
+        return { clear() { } };
+    }
+    let frameIndex = 0;
+    const interval = setInterval(() => {
+        const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
+        process.stderr.write(`\r${frame} ${message}`);
+        frameIndex++;
+    }, 80);
+    return {
+        clear() {
+            clearInterval(interval);
+            process.stderr.write('\r\u001B[2K');
+        },
+    };
+}

package/dist/oclif/lib/task-client.d.ts

@@ -20,6 +20,11 @@ export interface ToolCallRecord {
 /** Completion result passed to onCompleted callback */
 export interface TaskCompletionResult {
     logId?: string;
+    /** Pending review notification from the server, present when review is required after task completion. */
+    pendingReview?: {
+        pendingCount: number;
+        reviewUrl: string;
+    };
     result?: string;
     taskId: string;
     toolCalls: ToolCallRecord[];