byterover-cli 2.5.2 → 3.0.0

package/dist/tui/app/pages/init-project-page.d.ts

@@ -0,0 +1,9 @@
+/**
+ * InitProjectPage
+ *
+ * Shown when .brv/ doesn't exist at cwd.
+ * Confirms with the user, then runs local init + vc init via daemon.
+ * On success, invalidates status cache → useAppViewMode transitions forward.
+ */
+import React from 'react';
+export declare function InitProjectPage(): React.ReactNode;

package/dist/tui/app/pages/init-project-page.js

@@ -0,0 +1,54 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * InitProjectPage
+ *
+ * Shown when .brv/ doesn't exist at cwd.
+ * Confirms with the user, then runs local init + vc init via daemon.
+ * On success, invalidates status cache → useAppViewMode transitions forward.
+ */
+import { useQueryClient } from '@tanstack/react-query';
+import { Box, Text, useApp } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useState } from 'react';
+import { InitEvents } from '../../../shared/transport/events/init-events.js';
+import { VcEvents } from '../../../shared/transport/events/vc-events.js';
+import { EnterPrompt } from '../../components/enter-prompt.js';
+import { getStatusQueryOptions } from '../../features/status/api/get-status.js';
+import { useTheme } from '../../hooks/index.js';
+import { useTransportStore } from '../../stores/transport-store.js';
+import { MainLayout } from '../layouts/main-layout.js';
+export function InitProjectPage() {
+    const queryClient = useQueryClient();
+    const { theme: { colors }, } = useTheme();
+    const [state, setState] = useState('confirm');
+    const { exit } = useApp();
+    const [error, setError] = useState();
+    const runInit = useCallback(async () => {
+        setState('running');
+        try {
+            const { apiClient } = useTransportStore.getState();
+            if (!apiClient)
+                throw new Error('Not connected to daemon');
+            // Step 1: Local init
+            await apiClient.request(InitEvents.LOCAL, { force: false });
+            // Step 2: VC init
+            await apiClient.request(VcEvents.INIT, {});
+            setState('done');
+            // Invalidate status so useAppViewMode re-evaluates and transitions
+            queryClient.invalidateQueries(getStatusQueryOptions());
+        }
+        catch (error_) {
+            setError(error_ instanceof Error ? error_.message : 'Initialization failed');
+            setState('error');
+        }
+    }, [queryClient]);
+    const handleConfirm = useCallback((confirmed) => {
+        if (confirmed) {
+            runInit();
+        }
+        else {
+            exit();
+        }
+    }, [exit, runInit]);
+    return (_jsx(MainLayout, { showInput: false, children: _jsxs(Box, { flexDirection: "column", paddingTop: 1, children: [state === 'confirm' && (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { color: colors.secondary, children: ["Project not initialized in ", process.cwd()] }), _jsx(EnterPrompt, { action: "initialize ByteRover here", onEnter: () => handleConfirm(true) })] })), state === 'running' && (_jsxs(Text, { color: colors.text, children: [_jsx(Spinner, { type: "dots" }), " Initializing project..."] })), state === 'error' && _jsx(Text, { color: colors.errorText, children: error })] }) }));
+}

package/dist/tui/app/pages/protected-routes.js

@@ -2,13 +2,21 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useAppViewMode } from '../../features/onboarding/hooks/use-app-view-mode.js';
 import { ConfigProviderPage } from './config-provider-page.js';
 import { HomePage } from './home-page.js';
+// import {InitProjectPage} from './init-project-page.js'
 export function ProtectedRoutes() {
     const viewMode = useAppViewMode();
-    if (viewMode.type === 'loading') {
-        return null;
+    switch (viewMode.type) {
+        case 'config-provider': {
+            return _jsx(ConfigProviderPage, {});
+        }
+        // case 'init-project': {
+        //   return <InitProjectPage />
+        // }
+        case 'loading': {
+            return null;
+        }
+        case 'ready': {
+            return _jsx(HomePage, {});
+        }
     }
-    if (viewMode.type === 'config-provider') {
-        return _jsx(ConfigProviderPage, {});
-    }
-    return _jsx(HomePage, {});
 }

package/dist/tui/components/index.d.ts

@@ -11,8 +11,6 @@ export { EnterPrompt } from './enter-prompt.js';
 export { ExecutionChanges, ExecutionContent, ExecutionInput, ExecutionProgress, ExecutionStatus, ExpandedLogView, LogItem, truncateContent, } from './execution/index.js';
 export { Footer } from './footer.js';
 export { Header } from './header.js';
-export { Init } from './init.js';
-export type { InitProps } from './init.js';
 export { List } from './list.js';
 export { Logo } from './logo.js';
 export type { LogoVariant } from './logo.js';

package/dist/tui/components/index.js

@@ -9,7 +9,6 @@ export { EnterPrompt } from './enter-prompt.js';
 export { ExecutionChanges, ExecutionContent, ExecutionInput, ExecutionProgress, ExecutionStatus, ExpandedLogView, LogItem, truncateContent, } from './execution/index.js';
 export { Footer } from './footer.js';
 export { Header } from './header.js';
-export { Init } from './init.js';
 export { List } from './list.js';
 export { Logo } from './logo.js';
 export { Markdown } from './markdown.js';

package/dist/tui/features/activity/hooks/use-activity-logs.js

@@ -185,9 +185,15 @@ export function useActivityLogs() {
                 toolCallName: tc.toolName,
             }));
             const changes = composeChangesFromToolCalls(task.toolCalls);
+            let content = task.status === 'error' ? formatTaskError(task.error) : (task.result ?? '');
+            if (task.reviewNotification) {
+                const { pendingCount, reviewUrl } = task.reviewNotification;
+                const fileLabel = pendingCount === 1 ? 'file needs' : 'files need';
+                content += `\n\n⚠ ${pendingCount} ${fileLabel} review: ${reviewUrl}`;
+            }
             const activityLog = {
                 changes,
-                content: task.status === 'error' ? formatTaskError(task.error) : (task.result ?? ''),
+                content,
                 files: task.files,
                 folders: task.folders,
                 id: task.taskId,

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

@@ -14,6 +14,7 @@ import { queryCommand } from './query.js';
 import { resetCommand } from './reset.js';
 import { spaceCommand } from './space.js';
 import { statusCommand } from './status.js';
+import { vcCommand } from './vc.js';
 /**
  * Load all REPL slash commands.
  *
@@ -38,6 +39,8 @@ export const load = () => [
     modelCommand,
     // Space management
     spaceCommand,
+    // Git semantic (vc commands)
+    vcCommand,
     // Context tree management
     resetCommand,
     // Session management

package/dist/tui/features/commands/definitions/space-list.js

@@ -1,22 +1,13 @@
-import React from 'react';
-import { SpaceListView } from '../../space/components/space-list-view.js';
-import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
-const listFlags = {
-    json: Flags.boolean({
-        char: 'j',
-        default: false,
-        description: 'Output in JSON format',
-    }),
-};
+import { getStatus } from '../../status/api/get-status.js';
 export const spaceListCommand = {
-    async action(_context, args) {
-        const parsed = await parseReplArgs(args, { flags: listFlags, strict: false });
-        const json = parsed.flags.json ?? false;
-        return {
-            render: ({ onCancel, onComplete }) => React.createElement(SpaceListView, { json, onCancel, onComplete }),
-        };
+    async action() {
+        const { status } = await getStatus();
+        const isVc = status.contextTreeStatus === 'git_vc';
+        const content = isVc
+            ? 'The space list command has been deprecated. Visit the ByteRover web dashboard to view your spaces.'
+            : 'The space list command has been deprecated. Visit the ByteRover web dashboard to view your spaces and follow the migration guide to version control.';
+        return { content, messageType: 'error', type: 'message' };
     },
-    description: 'List all spaces for the current team',
-    flags: toCommandFlags(listFlags),
+    description: 'List all spaces (deprecated)',
     name: 'list',
 };

package/dist/tui/features/commands/definitions/space-switch.js

@@ -1,9 +1,13 @@
-import React from 'react';
-import { SpaceSwitchFlow } from '../../space/components/space-switch-flow.js';
+import { getStatus } from '../../status/api/get-status.js';
 export const spaceSwitchCommand = {
-    action: () => ({
-        render: ({ onCancel, onComplete }) => React.createElement(SpaceSwitchFlow, { onCancel, onComplete }),
-    }),
-    description: 'Switch to a different space',
+    async action() {
+        const { status } = await getStatus();
+        const isVc = status.contextTreeStatus === 'git_vc';
+        const content = isVc
+            ? 'The space switch command has been deprecated. To work with a different space, use: brv vc clone <url>'
+            : 'The space switch command has been deprecated. Visit the ByteRover web dashboard to follow the migration guide from snapshot to version control.';
+        return { content, messageType: 'error', type: 'message' };
+    },
+    description: 'Switch to a different space (deprecated)',
     name: 'switch',
 };

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

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

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import { VcAddFlow } from '../../vc/add/components/vc-add-flow.js';
+import { parseReplArgs } from '../utils/arg-parser.js';
+export const vcAddSubCommand = {
+    async action(_context, rawArgs) {
+        const parsed = await parseReplArgs(rawArgs, { strict: false });
+        // argv contains all non-flag tokens; default to '.' like git add .
+        const filePaths = parsed.argv.length > 0 ? parsed.argv : ['.'];
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcAddFlow, { filePaths, onCancel, onComplete }),
+        };
+    },
+    description: 'Stage files for the next commit',
+    name: 'add',
+};

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

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

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',
+};