byterover-cli 2.6.0 → 3.0.1

package/dist/tui/features/commands/definitions/vc-branch.js

@@ -0,0 +1,33 @@
+import React from 'react';
+import { VcBranchFlow } from '../../vc/branch/components/vc-branch-flow.js';
+import { Args, Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcBranchArgs = {
+    name: Args.string({ description: 'Branch name to create' }),
+};
+const vcBranchFlags = {
+    all: Flags.boolean({ char: 'a', default: false, description: 'List all branches including remote-tracking' }),
+    delete: Flags.string({ char: 'd', description: 'Delete a branch by name' }),
+    'set-upstream-to': Flags.string({ description: 'Set upstream tracking (e.g. origin/main)' }),
+};
+function resolveRequest(parsed) {
+    if (parsed.flags['set-upstream-to'])
+        return { action: 'set-upstream', upstream: parsed.flags['set-upstream-to'] };
+    if (parsed.flags.delete)
+        return { action: 'delete', name: parsed.flags.delete };
+    if (parsed.args.name)
+        return { action: 'create', name: parsed.args.name };
+    return { action: 'list', all: parsed.flags.all };
+}
+export const vcBranchSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcBranchArgs, flags: vcBranchFlags, strict: false });
+        const request = resolveRequest(parsed);
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcBranchFlow, { onCancel, onComplete, request }),
+        };
+    },
+    args: [{ description: 'Branch name to create', name: 'name' }],
+    description: 'List, create, or delete local branches',
+    flags: toCommandFlags(vcBranchFlags),
+    name: 'branch',
+};

package/dist/tui/features/commands/definitions/vc-checkout.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcCheckoutSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-checkout.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import { VcCheckoutFlow } from '../../vc/checkout/components/vc-checkout-flow.js';
+import { Args, Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcCheckoutArgs = {
+    branch: Args.string({ description: 'Branch to switch to', required: true }),
+};
+const vcCheckoutFlags = {
+    create: Flags.boolean({ char: 'b', default: false, description: 'Create a new branch and switch to it' }),
+    force: Flags.boolean({ default: false, description: 'Discard local changes and switch' }),
+};
+function resolveRequest(parsed) {
+    if (!parsed.args.branch)
+        throw new Error('Branch name is required.');
+    return {
+        branch: parsed.args.branch,
+        create: parsed.flags.create,
+        force: parsed.flags.force,
+    };
+}
+export const vcCheckoutSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcCheckoutArgs, flags: vcCheckoutFlags, strict: false });
+        const request = resolveRequest(parsed);
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcCheckoutFlow, { onCancel, onComplete, request }),
+        };
+    },
+    args: [{ description: 'Branch to switch to', name: 'branch', required: true }],
+    description: 'Switch to an existing branch, or create and switch with -b',
+    flags: toCommandFlags(vcCheckoutFlags),
+    name: 'checkout',
+};

package/dist/tui/features/commands/definitions/vc-clone.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcCloneSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-clone.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { VcCloneFlow } from '../../vc/clone/components/vc-clone-flow.js';
+import { Args, parseReplArgs } from '../utils/arg-parser.js';
+const vcCloneArgs = {
+    url: Args.string({ description: 'Clone URL (optional — prompts for URL if omitted)' }),
+};
+export const vcCloneSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcCloneArgs, strict: false });
+        const { url } = parsed.args;
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcCloneFlow, { onCancel, onComplete, url }),
+        };
+    },
+    args: [{ description: 'Clone URL (optional)', name: 'url' }],
+    description: 'Clone a ByteRover space repository',
+    name: 'clone',
+};

package/dist/tui/features/commands/definitions/vc-commit.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcCommitSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-commit.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import { VcCommitFlow } from '../../vc/commit/components/vc-commit-flow.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcCommitFlags = {
+    message: Flags.string({ char: 'm', description: 'Commit message' }),
+};
+export const vcCommitSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { flags: vcCommitFlags, strict: false });
+        // Join remaining argv with the flag value to support unquoted multi-word messages
+        // e.g. /vc commit -m hello world → message = "hello world"
+        // e.g. /vc commit hello world    → message = "hello world"
+        const extra = parsed.argv.join(' ');
+        const message = parsed.flags.message
+            ? (extra ? `${parsed.flags.message} ${extra}` : parsed.flags.message)
+            : (extra || undefined);
+        if (!message) {
+            const errorMsg = {
+                content: 'Usage: /vc commit -m "<message>"',
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcCommitFlow, { message, onCancel, onComplete }),
+        };
+    },
+    description: 'Save staged changes as a commit',
+    flags: toCommandFlags(vcCommitFlags),
+    name: 'commit',
+};

package/dist/tui/features/commands/definitions/vc-config.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcConfigSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-config.js

@@ -0,0 +1,40 @@
+import React from 'react';
+import { isVcConfigKey } from '../../../../shared/transport/events/vc-events.js';
+import { VcConfigFlow } from '../../vc/config/components/vc-config-flow.js';
+import { Args, parseReplArgs } from '../utils/arg-parser.js';
+const vcConfigArgs = {
+    key: Args.string({ description: 'Config key (user.name or user.email)' }),
+    value: Args.string({ description: 'Config value to set (omit to get current value)' }),
+};
+export const vcConfigSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcConfigArgs, strict: false });
+        const { key } = parsed.args;
+        const { value } = parsed.args;
+        if (!key) {
+            const errorMsg = {
+                content: 'Usage: /vc config user.name "<value>" | /vc config user.email "<value>"',
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        if (!isVcConfigKey(key)) {
+            const errorMsg = {
+                content: `Unknown key '${key}'. Allowed: user.name, user.email.`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcConfigFlow, { configKey: key, onCancel, onComplete, value }),
+        };
+    },
+    args: [
+        { description: 'Config key (user.name or user.email)', name: 'key' },
+        { description: 'Value to set (omit to read current value)', name: 'value' },
+    ],
+    description: 'Get or set commit author for ByteRover version control',
+    name: 'config',
+};

package/dist/tui/features/commands/definitions/vc-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcFetchSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-fetch.js

@@ -0,0 +1,37 @@
+import React from 'react';
+import { VcFetchFlow } from '../../vc/fetch/components/vc-fetch-flow.js';
+import { Args, parseReplArgs } from '../utils/arg-parser.js';
+/* eslint-disable perfectionist/sort-objects -- positional order matters: remote before branch */
+const vcFetchArgs = {
+    remote: Args.string({ description: 'Remote name (only origin supported)' }),
+    branch: Args.string({ description: 'Branch to fetch' }),
+};
+/* eslint-enable perfectionist/sort-objects */
+export const vcFetchSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcFetchArgs, strict: false });
+        const { branch, remote } = parsed.args;
+        if (remote && remote !== 'origin') {
+            const errorMsg = {
+                content: `Only 'origin' remote is currently supported.`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcFetchFlow, {
+                onCancel,
+                onComplete,
+                ref: branch,
+                remote,
+            }),
+        };
+    },
+    args: [
+        { description: 'Remote name (only origin supported)', name: 'remote', required: false },
+        { description: 'Branch to fetch', name: 'branch', required: false },
+    ],
+    description: 'Fetch refs from ByteRover cloud',
+    name: 'fetch',
+};

package/dist/tui/features/commands/definitions/vc-init.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcInitSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-init.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { VcInitFlow } from '../../vc/init/components/vc-init-flow.js';
+export const vcInitSubCommand = {
+    action() {
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcInitFlow, { onCancel, onComplete }),
+        };
+    },
+    description: 'Initialize ByteRover version control for context tree',
+    name: 'init',
+};

package/dist/tui/features/commands/definitions/vc-log.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcLogSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-log.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import { LogFlow } from '../../log/components/log-flow.js';
+import { Args, Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcLogArgs = {
+    branch: Args.string({ description: 'Branch name to show history for' }),
+};
+const vcLogFlags = {
+    all: Flags.boolean({ char: 'a', default: false, description: 'Show commits from all branches' }),
+    limit: Flags.string({ default: '10', description: 'Number of commits to show (default: 10)' }),
+};
+export const vcLogSubCommand = {
+    async action(_context, args) {
+        const parsed = await parseReplArgs(args, { args: vcLogArgs, flags: vcLogFlags, strict: false });
+        const limit = Number(parsed.flags.limit ?? '10');
+        const all = parsed.flags.all ?? false;
+        const { branch } = parsed.args;
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(LogFlow, { all, branch, limit, onCancel, onComplete }),
+        };
+    },
+    args: [{ description: 'Branch name to show history for', name: 'branch' }],
+    description: 'Show commit history for the context-tree',
+    flags: toCommandFlags(vcLogFlags),
+    name: 'log',
+};

package/dist/tui/features/commands/definitions/vc-merge.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcMergeSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-merge.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import { VcMergeFlow } from '../../vc/merge/components/vc-merge-flow.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcMergeFlags = {
+    abort: Flags.boolean({ description: 'Abort the current merge', exclusive: ['continue'] }),
+    'allow-unrelated-histories': Flags.boolean({ default: false, description: 'Allow merging unrelated histories' }),
+    continue: Flags.boolean({ description: 'Continue after resolving conflicts', exclusive: ['abort'] }),
+    message: Flags.string({ char: 'm', description: 'Merge commit message' }),
+};
+export const vcMergeSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { flags: vcMergeFlags, strict: false });
+        const { abort, continue: cont, message } = parsed.flags;
+        const branch = parsed.argv[0];
+        if (abort) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcMergeFlow, { action: 'abort', onCancel, onComplete }),
+            };
+        }
+        if (cont) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcMergeFlow, { action: 'continue', message, onCancel, onComplete }),
+            };
+        }
+        if (!branch) {
+            const errorMsg = {
+                content: 'Usage: /vc merge <branch> | --abort | --continue',
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcMergeFlow, {
+                action: 'merge',
+                allowUnrelatedHistories: parsed.flags['allow-unrelated-histories'],
+                branch,
+                message,
+                onCancel,
+                onComplete,
+            }),
+        };
+    },
+    args: [{ description: 'Branch to merge', name: 'branch', required: false }],
+    description: 'Merge a branch into the current branch',
+    flags: toCommandFlags(vcMergeFlags),
+    name: 'merge',
+};

package/dist/tui/features/commands/definitions/vc-pull.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcPullSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-pull.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import { VcPullFlow } from '../../vc/pull/components/vc-pull-flow.js';
+import { Args, Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+/* eslint-disable perfectionist/sort-objects -- positional order matters: remote before branch */
+const vcPullArgs = {
+    remote: Args.string({ description: 'Remote name (only origin supported)' }),
+    branch: Args.string({ description: 'Branch to pull' }),
+};
+/* eslint-enable perfectionist/sort-objects */
+const vcPullFlags = {
+    'allow-unrelated-histories': Flags.boolean({ default: false, description: 'Allow merging unrelated histories' }),
+};
+export const vcPullSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcPullArgs, flags: vcPullFlags, strict: false });
+        const { branch, remote } = parsed.args;
+        if (remote && remote !== 'origin') {
+            const errorMsg = {
+                content: `Only 'origin' remote is currently supported.`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcPullFlow, {
+                allowUnrelatedHistories: parsed.flags['allow-unrelated-histories'],
+                branch,
+                onCancel,
+                onComplete,
+                remote,
+            }),
+        };
+    },
+    args: [
+        { description: 'Remote name (only origin supported)', name: 'remote', required: false },
+        { description: 'Branch to pull', name: 'branch', required: false },
+    ],
+    description: 'Pull commits from ByteRover cloud',
+    flags: toCommandFlags(vcPullFlags),
+    name: 'pull',
+};

package/dist/tui/features/commands/definitions/vc-push.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcPushSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-push.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import { VcPushFlow } from '../../vc/push/components/vc-push-flow.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcPushFlags = {
+    'set-upstream': Flags.boolean({ char: 'u', description: 'Set upstream tracking branch' }),
+};
+export const vcPushSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { flags: vcPushFlags, strict: false });
+        const { 'set-upstream': setUpstream } = parsed.flags;
+        const positional = parsed.argv ?? [];
+        // Git push semantics: push [<remote> [<branch>]]
+        //   /vc push                → current branch
+        //   /vc push origin         → current branch (explicit remote)
+        //   /vc push origin feat/x  → feat/x
+        //   /vc push feat/x         → error (unknown remote)
+        let branch;
+        if (positional.length >= 2) {
+            if (positional[0] !== 'origin') {
+                throw new Error(`Unknown remote '${positional[0]}'.`);
+            }
+            branch = positional[1];
+        }
+        else if (positional.length === 1 && positional[0] !== 'origin') {
+            throw new Error(`Unknown remote '${positional[0]}'. Use '/vc push origin ${positional[0]}' to push a specific branch.`);
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcPushFlow, { branch, onCancel, onComplete, setUpstream }),
+        };
+    },
+    args: [
+        { description: 'Remote name (e.g. origin)', name: 'remote', required: false },
+        { description: 'Branch to push to', name: 'branch', required: false },
+    ],
+    description: 'Push commits to ByteRover cloud',
+    flags: toCommandFlags(vcPushFlags),
+    name: 'push',
+};

package/dist/tui/features/commands/definitions/vc-remote.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcRemoteSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-remote.js

@@ -0,0 +1,57 @@
+import React from 'react';
+import { isVcRemoteSubcommand } from '../../../../shared/transport/events/vc-events.js';
+import { getGitRemoteBaseUrl } from '../../../lib/environment.js';
+import { VcRemoteFlow } from '../../vc/remote/components/vc-remote-flow.js';
+import { Args, parseReplArgs } from '../utils/arg-parser.js';
+/* eslint-disable perfectionist/sort-objects -- positional order matters: subcommand, name, url */
+const vcRemoteArgs = {
+    subcommand: Args.string({ description: 'Subcommand: add | set-url (omit to show current remote)' }),
+    name: Args.string({ description: 'Remote name (e.g. origin)' }),
+    url: Args.string({ description: `Remote URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)` }),
+};
+/* eslint-enable perfectionist/sort-objects */
+export const vcRemoteSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { args: vcRemoteArgs, strict: false });
+        const { name, subcommand: rawSubcommand, url } = parsed.args;
+        if (!rawSubcommand) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcRemoteFlow, { onCancel, onComplete, subcommand: 'show' }),
+            };
+        }
+        if (!isVcRemoteSubcommand(rawSubcommand)) {
+            const errorMsg = {
+                content: `Unknown subcommand '${rawSubcommand}'. Usage: /vc remote [add|set-url] <name> <url>`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        if (!name || !url) {
+            const errorMsg = {
+                content: `Usage: /vc remote ${rawSubcommand} <name> <url>`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        if (name !== 'origin') {
+            const errorMsg = {
+                content: `Only 'origin' remote is currently supported.`,
+                messageType: 'error',
+                type: 'message',
+            };
+            return errorMsg;
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcRemoteFlow, { onCancel, onComplete, subcommand: rawSubcommand, url }),
+        };
+    },
+    args: [
+        { description: 'Subcommand: add | set-url (omit to show current remote)', name: 'subcommand' },
+        { description: 'Remote name (e.g. origin)', name: 'name' },
+        { description: 'Remote URL', name: 'url' },
+    ],
+    description: 'Manage remote origin for ByteRover version control',
+    name: 'remote',
+};

package/dist/tui/features/commands/definitions/vc-reset.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcResetSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-reset.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import { VcResetFlow } from '../../vc/reset/components/vc-reset-flow.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcResetFlags = {
+    hard: Flags.boolean({ description: 'Reset HEAD, index, and working tree', exclusive: ['soft'] }),
+    soft: Flags.boolean({ description: 'Reset HEAD only, keep changes staged', exclusive: ['hard'] }),
+};
+export const vcResetSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { flags: vcResetFlags, strict: false });
+        const { hard, soft } = parsed.flags;
+        const args = parsed.argv.filter((a) => typeof a === 'string');
+        // When --soft or --hard is set, first arg is the optional ref (default HEAD)
+        const mode = soft ? 'soft' : hard ? 'hard' : undefined;
+        const ref = mode ? args[0] : undefined;
+        const filePaths = mode ? undefined : (args.length > 0 ? args : undefined);
+        if (filePaths) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcResetFlow, { filePaths, onCancel, onComplete }),
+            };
+        }
+        if (mode) {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcResetFlow, { mode, onCancel, onComplete, ref }),
+            };
+        }
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcResetFlow, { onCancel, onComplete }),
+        };
+    },
+    args: [{ description: 'File paths to unstage', name: 'files', required: false }],
+    description: 'Unstage files or undo commits',
+    flags: toCommandFlags(vcResetFlags),
+    name: 'reset',
+};

package/dist/tui/features/commands/definitions/vc-status.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcStatusSubCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc-status.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { VcStatusFlow } from '../../vc/status/components/vc-status-flow.js';
+export const vcStatusSubCommand = {
+    action() {
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcStatusFlow, { onCancel, onComplete }),
+        };
+    },
+    description: 'Show ByteRover version control status',
+    name: 'status',
+};

package/dist/tui/features/commands/definitions/vc.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const vcCommand: SlashCommand;

package/dist/tui/features/commands/definitions/vc.js

@@ -0,0 +1,36 @@
+import { vcAddSubCommand } from './vc-add.js';
+import { vcBranchSubCommand } from './vc-branch.js';
+import { vcCheckoutSubCommand } from './vc-checkout.js';
+import { vcCloneSubCommand } from './vc-clone.js';
+import { vcCommitSubCommand } from './vc-commit.js';
+import { vcConfigSubCommand } from './vc-config.js';
+import { vcFetchSubCommand } from './vc-fetch.js';
+import { vcInitSubCommand } from './vc-init.js';
+import { vcLogSubCommand } from './vc-log.js';
+import { vcMergeSubCommand } from './vc-merge.js';
+import { vcPullSubCommand } from './vc-pull.js';
+import { vcPushSubCommand } from './vc-push.js';
+import { vcRemoteSubCommand } from './vc-remote.js';
+import { vcResetSubCommand } from './vc-reset.js';
+import { vcStatusSubCommand } from './vc-status.js';
+export const vcCommand = {
+    description: 'Version control commands for ByteRover',
+    name: 'vc',
+    subCommands: [
+        vcCloneSubCommand,
+        vcInitSubCommand,
+        vcAddSubCommand,
+        vcCommitSubCommand,
+        vcResetSubCommand,
+        vcFetchSubCommand,
+        vcPullSubCommand,
+        vcPushSubCommand,
+        vcStatusSubCommand,
+        vcLogSubCommand,
+        vcMergeSubCommand,
+        vcBranchSubCommand,
+        vcCheckoutSubCommand,
+        vcConfigSubCommand,
+        vcRemoteSubCommand,
+    ],
+};

package/dist/tui/features/commands/hooks/use-slash-command-processor.js

@@ -96,14 +96,14 @@ export function useSlashCommandProcessor(context, commands) {
                 type: 'message',
             };
         }
-        // Extract file and folder references from args
-        const { args: argsWithoutFiles, files, folders } = splitArgs(args);
-        const cleanArgs = argsWithoutFiles.join(' ');
+        // Extract file and folder references from args for context metadata.
+        // Pass the original args string to the action — parseReplArgs handles quote-aware splitting internally.
+        const { files, folders } = splitArgs(args);
         // Build execution context with invocation details
         const execContext = {
             ...context,
             invocation: {
-                args: cleanArgs,
+                args,
                 files,
                 folders,
                 name: commandNameForContext,
@@ -112,7 +112,7 @@ export function useSlashCommandProcessor(context, commands) {
         };
         setIsProcessing(true);
         try {
-            const result = await actionToExecute(execContext, cleanArgs);
+            const result = await actionToExecute(execContext, args);
             return result;
         }
         catch (error) {

package/dist/tui/features/log/api/execute-log.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../lib/react-query.js';
+import { type IVcLogRequest, type IVcLogResponse } from '../../../../shared/transport/events/vc-events.js';
+export declare const executeLog: (req: IVcLogRequest) => Promise<IVcLogResponse>;
+type UseExecuteLogOptions = {
+    mutationConfig?: MutationConfig<typeof executeLog>;
+};
+export declare const useExecuteLog: ({ mutationConfig }?: UseExecuteLogOptions) => import("@tanstack/react-query").UseMutationResult<IVcLogResponse, Error, IVcLogRequest, unknown>;
+export {};

package/dist/tui/features/log/api/execute-log.js

@@ -0,0 +1,13 @@
+import { useMutation } from '@tanstack/react-query';
+import { VcEvents } from '../../../../shared/transport/events/vc-events.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const executeLog = (req) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.LOG, req);
+};
+export const useExecuteLog = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeLog,
+});

package/dist/tui/features/log/components/log-flow.d.ts

@@ -0,0 +1,14 @@
+/**
+ * LogFlow Component
+ *
+ * Fetches and displays git commit history for the context-tree via VcHandler.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../types/commands.js';
+type LogFlowProps = CustomDialogCallbacks & {
+    all: boolean;
+    branch: string | undefined;
+    limit: number;
+};
+export declare function LogFlow({ all, branch, limit, onComplete }: LogFlowProps): React.ReactNode;
+export {};