byterover-cli 2.6.0 → 3.0.1

package/dist/tui/features/log/components/log-flow.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * LogFlow Component
+ *
+ * Fetches and displays git commit history for the context-tree via VcHandler.
+ */
+import { Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useEffect } from 'react';
+import { useExecuteLog } from '../api/execute-log.js';
+import { formatCommitLog } from '../utils/format-log.js';
+export function LogFlow({ all, branch, limit, onComplete }) {
+    const logMutation = useExecuteLog();
+    useEffect(() => {
+        logMutation.mutate({ all, limit, ref: branch }, {
+            onError(error) {
+                onComplete(`Failed to get log: ${error.message.replace(/ for event '[^']+'$/, '')}`);
+            },
+            onSuccess(result) {
+                if (result.commits.length === 0) {
+                    onComplete('No commits found.');
+                    return;
+                }
+                onComplete(formatCommitLog(result.commits, result.currentBranch));
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Loading commit history..."] }));
+}

package/dist/tui/features/log/utils/format-log.d.ts

@@ -0,0 +1,3 @@
+import type { IVcLogResponse } from '../../../../shared/transport/events/vc-events.js';
+export declare function formatRelativeDate(date: Date): string;
+export declare function formatCommitLog(commits: IVcLogResponse['commits'], currentBranch?: string): string;

package/dist/tui/features/log/utils/format-log.js

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+export function formatRelativeDate(date) {
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    const diffSec = Math.floor(diffMs / 1000);
+    if (diffSec < 60)
+        return `${diffSec} second${diffSec === 1 ? '' : 's'} ago`;
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60)
+        return `${diffMin} minute${diffMin === 1 ? '' : 's'} ago`;
+    const diffHour = Math.floor(diffMin / 60);
+    if (diffHour < 24)
+        return `${diffHour} hour${diffHour === 1 ? '' : 's'} ago`;
+    const diffDay = Math.floor(diffHour / 24);
+    if (diffDay < 30)
+        return `${diffDay} day${diffDay === 1 ? '' : 's'} ago`;
+    const diffMonth = Math.floor(diffDay / 30);
+    if (diffMonth < 12)
+        return `${diffMonth} month${diffMonth === 1 ? '' : 's'} ago`;
+    const diffYear = Math.floor(diffMonth / 12);
+    return `${diffYear} year${diffYear === 1 ? '' : 's'} ago`;
+}
+export function formatCommitLog(commits, currentBranch) {
+    if (commits.length === 0)
+        return '';
+    return commits
+        .map((commit, index) => {
+        const shortSha = chalk.yellow(commit.sha.slice(0, 7));
+        const headMarker = index === 0
+            ? currentBranch
+                ? ` ${chalk.yellow.bold(`(HEAD -> ${currentBranch})`)}`
+                : ` ${chalk.yellow.bold('(HEAD)')}`
+            : '';
+        const relativeDate = formatRelativeDate(new Date(commit.timestamp));
+        return [
+            `* ${shortSha}${headMarker} ${commit.message}`,
+            `  Author: ${commit.author.name} <${commit.author.email}>`,
+            `  ${relativeDate}`,
+        ].join('\n');
+    })
+        .join('\n\n');
+}

package/dist/tui/features/onboarding/hooks/use-app-view-mode.d.ts

@@ -5,10 +5,12 @@
  * This is the single source of truth for determining what UI to show.
  */
 /**
- * The valid application view modes as a discriminated union.
+ * Application view modes as a discriminated union.
  */
 export type AppViewMode = {
     type: 'config-provider';
+} | {
+    type: 'init-project';
 } | {
     type: 'loading';
 } | {
@@ -20,6 +22,7 @@ export type AppViewMode = {
 export type DeriveAppViewModeParams = {
     activeModel?: string;
     activeProviderId?: string;
+    contextTreeStatus?: string;
     isAuthorized: boolean;
     isLoading: boolean;
 };
@@ -29,10 +32,11 @@ export type DeriveAppViewModeParams = {
  *
  * Decision tree:
  * 1. Loading → 'loading'
- * 2. ByteRover + unauthenticated → 'config-provider'
- * 3. ByteRover + authenticated → 'ready'
- * 4. Non-byterover + no active model → 'config-provider'
- * 5. Otherwise → 'ready'
+ * 2. Project not initialized → 'init-project'
+ * 3. ByteRover + unauthenticated → 'config-provider'
+ * 4. ByteRover + authenticated → 'ready'
+ * 5. Non-byterover + no active model → 'config-provider'
+ * 6. Otherwise → 'ready'
  */
 export declare function deriveAppViewMode(params: DeriveAppViewModeParams): AppViewMode;
 /**

package/dist/tui/features/onboarding/hooks/use-app-view-mode.js

@@ -6,21 +6,26 @@
  */
 import { useAuthStore } from '../../auth/stores/auth-store.js';
 import { useGetActiveProviderConfig } from '../../provider/api/get-active-provider-config.js';
+import { useGetStatus } from '../../status/api/get-status.js';
 /**
  * Pure decision logic for determining the app view mode.
  * Extracted from useAppViewMode for testability.
  *
  * Decision tree:
  * 1. Loading → 'loading'
- * 2. ByteRover + unauthenticated → 'config-provider'
- * 3. ByteRover + authenticated → 'ready'
- * 4. Non-byterover + no active model → 'config-provider'
- * 5. Otherwise → 'ready'
+ * 2. Project not initialized → 'init-project'
+ * 3. ByteRover + unauthenticated → 'config-provider'
+ * 4. ByteRover + authenticated → 'ready'
+ * 5. Non-byterover + no active model → 'config-provider'
+ * 6. Otherwise → 'ready'
  */
 export function deriveAppViewMode(params) {
     if (params.isLoading) {
         return { type: 'loading' };
     }
+    // if (['not_initialized', 'unknown'].includes(params.contextTreeStatus || '')) {
+    //   return {type: 'init-project'}
+    // }
     if (params.activeProviderId === 'byterover' && !params.isAuthorized) {
         return { type: 'config-provider' };
     }
@@ -38,11 +43,13 @@ export function deriveAppViewMode(params) {
  */
 export function useAppViewMode() {
     const { isAuthorized, isLoadingInitial: isLoadingAuth } = useAuthStore();
+    const { data: statusData, isLoading: isLoadingStatus } = useGetStatus();
     const { data: activeData, isLoading: isLoadingActive } = useGetActiveProviderConfig();
     return deriveAppViewMode({
         activeModel: activeData?.activeModel,
         activeProviderId: activeData?.activeProviderId,
+        contextTreeStatus: statusData?.status.contextTreeStatus,
         isAuthorized,
-        isLoading: isLoadingAuth || isLoadingActive,
+        isLoading: isLoadingAuth || isLoadingStatus || isLoadingActive,
     });
 }

package/dist/tui/features/push/components/push-flow.js

@@ -27,7 +27,14 @@ export function PushFlow({ branch, onComplete, skipConfirm }) {
             return;
         }
         if (prepareData && !prepareData.hasChanges) {
-            onComplete('No context changes to push.');
+            if (prepareData.excludedReviewCount > 0) {
+                const fileLabel = prepareData.excludedReviewCount === 1 ? 'file is' : 'files are';
+                onComplete(`No pushable changes. ${prepareData.excludedReviewCount} ${fileLabel} pending review.` +
+                    (prepareData.reviewUrl ? `\n  Review: ${prepareData.reviewUrl}` : ''));
+            }
+            else {
+                onComplete('No context changes to push.');
+            }
             return;
         }
         if (prepareData) {
@@ -70,7 +77,7 @@ export function PushFlow({ branch, onComplete, skipConfirm }) {
         return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Checking for Context Tree changes..."] }));
     }
     if (step === 'confirm' && prepareData) {
-        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: `Changes found: ${prepareData.summary} (${prepareData.fileCount} files)` }), _jsx(Text, { children: `\nYou are about to push to ByteRover memory storage:` }), _jsx(Text, { children: `  Branch: ${branch}` }), _jsx(InlineConfirm, { default: false, message: "Push to ByteRover", onConfirm: (confirmed) => {
+        return (_jsxs(_Fragment, { children: [_jsx(Text, { children: `Changes found: ${prepareData.summary} (${prepareData.fileCount} files)` }), prepareData.excludedReviewCount > 0 && (_jsxs(Text, { color: "yellow", children: [`⚠ ${prepareData.excludedReviewCount} file(s) excluded from push (pending/rejected review).`, prepareData.reviewUrl ? `\n  Review: ${prepareData.reviewUrl}` : ''] })), _jsx(Text, { children: `\nYou are about to push to ByteRover memory storage:` }), _jsx(Text, { children: `  Branch: ${branch}` }), _jsx(InlineConfirm, { default: false, message: "Push to ByteRover", onConfirm: (confirmed) => {
                         if (confirmed) {
                             setStep('executing');
                         }

package/dist/tui/features/reset/components/reset-flow.js

@@ -8,6 +8,7 @@ import { Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useEffect, useState } from 'react';
 import { InlineConfirm } from '../../../components/inline-prompts/inline-confirm.js';
+import { formatTransportError } from '../../../utils/error-messages.js';
 import { useExecuteReset } from '../api/execute-reset.js';
 export function ResetFlow({ onComplete, skipConfirm }) {
     const [step, setStep] = useState(skipConfirm ? 'executing' : 'confirm');
@@ -18,7 +19,7 @@ export function ResetFlow({ onComplete, skipConfirm }) {
             return;
         resetMutation.mutate(undefined, {
             onError(error) {
-                onComplete(`Failed to reset context tree: ${error.message}`);
+                onComplete(`Failed to reset context tree: ${formatTransportError(error)}`);
             },
             onSuccess(result) {
                 if (result.success) {

package/dist/tui/features/status/components/status-view.js

@@ -7,6 +7,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { useEffect } from 'react';
+import { formatTransportError } from '../../../utils/error-messages.js';
 import { useGetStatus } from '../api/get-status.js';
 import { formatStatus } from '../utils/format-status.js';
 export function StatusView({ onComplete, version }) {
@@ -16,7 +17,7 @@ export function StatusView({ onComplete, version }) {
             onComplete(formatStatus(data.status, version));
         }
         if (error) {
-            onComplete(`Failed to get status: ${error.message}`);
+            onComplete(`Failed to get status: ${formatTransportError(error)}`);
         }
     }, [data, error, onComplete, version]);
     if (isLoading) {

package/dist/tui/features/status/utils/format-status.js

@@ -30,6 +30,10 @@ export function formatStatus(status, version) {
         lines.push('Space: Not connected');
     }
     switch (status.contextTreeStatus) {
+        case 'git_vc': {
+            lines.push('Context Tree: Byterover version control (use /vc commands)');
+            break;
+        }
         case 'has_changes': {
             if (status.contextTreeChanges && status.contextTreeRelativeDir) {
                 const { added, deleted, modified } = status.contextTreeChanges;
@@ -58,5 +62,10 @@ export function formatStatus(status, version) {
             lines.push('Context Tree: Unable to check status');
         }
     }
+    if (status.pendingReviewCount && status.pendingReviewCount > 0) {
+        const fileLabel = status.pendingReviewCount === 1 ? 'file' : 'files';
+        lines.push(chalk.yellow(`Pending Reviews: ${status.pendingReviewCount} ${fileLabel} need review`) +
+            (status.reviewUrl ? `\n  Review: ${chalk.blue(status.reviewUrl)}` : ''));
+    }
     return lines.join('\n');
 }

package/dist/tui/features/tasks/hooks/use-task-subscriptions.js

@@ -3,6 +3,7 @@
  * Call this once from a top-level component to wire up task lifecycle events.
  */
 import { useEffect } from 'react';
+import { ReviewEvents } from '../../../../shared/transport/events/review-events.js';
 import { useTransportStore } from '../../../stores/transport-store.js';
 import { useTasksStore } from '../stores/tasks-store.js';
 export function useTaskSubscriptions() {
@@ -65,6 +66,16 @@ export function useTaskSubscriptions() {
                 taskId: data.taskId,
                 type: data.type === 'reasoning' ? 'reasoning' : 'text',
             });
+        }), client.on(ReviewEvents.NOTIFY, (data) => {
+            if (data.pendingCount === 0) {
+                store.clearReviewNotification(data.taskId);
+            }
+            else {
+                store.setReviewNotification(data.taskId, {
+                    pendingCount: data.pendingCount,
+                    reviewUrl: data.reviewUrl,
+                });
+            }
         }));
         return () => {
             for (const unsub of unsubscribers)

package/dist/tui/features/tasks/stores/tasks-store.d.ts

@@ -26,6 +26,10 @@ export interface TaskErrorData {
     code?: string;
     message: string;
 }
+export interface ReviewNotification {
+    pendingCount: number;
+    reviewUrl: string;
+}
 export interface Task {
     completedAt?: number;
     content: string;
@@ -37,6 +41,8 @@ export interface Task {
     isStreaming?: boolean;
     reasoningContents?: ReasoningContentItem[];
     result?: string;
+    /** Set when curate completes with pending HITL review operations. */
+    reviewNotification?: ReviewNotification;
     sessionId?: string;
     startedAt?: number;
     status: TaskStatus;
@@ -62,6 +68,8 @@ export interface TasksActions {
         taskId: string;
         type: 'reasoning' | 'text';
     }) => void;
+    /** Clear the review notification on a task (called after approve/reject) */
+    clearReviewNotification: (taskId: string) => void;
     /** Clear all tasks */
     clearTasks: () => void;
     /** Create a new task */
@@ -76,6 +84,8 @@ export interface TasksActions {
     setError: (taskId: string, error: TaskErrorData) => void;
     /** Set task LLM response (final) */
     setResponse: (taskId: string, content: string, sessionId?: string) => void;
+    /** Set review notification on a completed curate task */
+    setReviewNotification: (taskId: string, notification: ReviewNotification) => void;
     /** Set task to started */
     setStarted: (taskId: string) => void;
     /** Update a tool call result */

package/dist/tui/features/tasks/stores/tasks-store.js

@@ -103,6 +103,14 @@ export const useTasksStore = create()((set, get) => ({
         }
         return { stats: computeStats(tasks), tasks };
     }),
+    clearReviewNotification: (taskId) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task?.reviewNotification)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, reviewNotification: undefined });
+        return { stats: computeStats(tasks), tasks };
+    }),
     clearTasks: () => set({ stats: { created: 0, started: 0 }, tasks: new Map() }),
     createTask: (taskId, type, content, files) => set((state) => {
         const tasks = new Map(state.tasks);
@@ -218,6 +226,14 @@ export const useTasksStore = create()((set, get) => ({
         });
         return { stats: computeStats(tasks), tasks };
     }),
+    setReviewNotification: (taskId, notification) => set((state) => {
+        const task = state.tasks.get(taskId);
+        if (!task)
+            return state;
+        const tasks = new Map(state.tasks);
+        tasks.set(taskId, { ...task, reviewNotification: notification });
+        return { stats: computeStats(tasks), tasks };
+    }),
     setStarted: (taskId) => set((state) => {
         const task = state.tasks.get(taskId);
         if (!task)

package/dist/tui/features/vc/add/api/execute-vc-add.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcAddRequest, type IVcAddResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcAdd: (request: IVcAddRequest) => Promise<IVcAddResponse>;
+type UseExecuteVcAddOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcAdd>;
+};
+export declare const useExecuteVcAdd: ({ mutationConfig }?: UseExecuteVcAddOptions) => import("@tanstack/react-query").UseMutationResult<IVcAddResponse, Error, IVcAddRequest, unknown>;
+export {};

package/dist/tui/features/vc/add/api/execute-vc-add.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 executeVcAdd = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.ADD, request);
+};
+export const useExecuteVcAdd = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcAdd,
+});

package/dist/tui/features/vc/add/components/vc-add-flow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcAddFlowProps = CustomDialogCallbacks & {
+    filePaths: string[];
+};
+export declare function VcAddFlow({ filePaths, onCancel, onComplete }: VcAddFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/add/components/vc-add-flow.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcAdd } from '../api/execute-vc-add.js';
+export function VcAddFlow({ filePaths, onCancel, onComplete }) {
+    const addMutation = useExecuteVcAdd();
+    useInput((_, key) => {
+        if (key.escape && !addMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        addMutation.mutate({ filePaths }, {
+            onError(error) {
+                onComplete(`Failed to stage: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.count === 0) {
+                    onComplete('Nothing to stage.');
+                }
+                else {
+                    onComplete(`Staged ${result.count} file(s).`);
+                }
+            },
+        });
+    }, []);
+    const label = filePaths.length === 1 && filePaths[0] === '.' ? '.' : filePaths.join(' ');
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Staging ", label, "..."] }));
+}

package/dist/tui/features/vc/branch/api/execute-vc-branch.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcBranchRequest, type IVcBranchResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcBranch: (request: IVcBranchRequest) => Promise<IVcBranchResponse>;
+type UseExecuteVcBranchOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcBranch>;
+};
+export declare const useExecuteVcBranch: ({ mutationConfig }?: UseExecuteVcBranchOptions) => import("@tanstack/react-query").UseMutationResult<IVcBranchResponse, Error, IVcBranchRequest, unknown>;
+export {};

package/dist/tui/features/vc/branch/api/execute-vc-branch.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 executeVcBranch = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.BRANCH, request);
+};
+export const useExecuteVcBranch = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcBranch,
+});

package/dist/tui/features/vc/branch/components/vc-branch-flow.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IVcBranchRequest } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcBranchFlowProps = CustomDialogCallbacks & {
+    request: IVcBranchRequest;
+};
+export declare function VcBranchFlow({ onCancel, onComplete, request }: VcBranchFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/branch/components/vc-branch-flow.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcBranch } from '../api/execute-vc-branch.js';
+import { formatBranchList } from '../utils/format-branch.js';
+const LABELS = {
+    create: 'Creating branch...',
+    delete: 'Deleting branch...',
+    list: 'Listing branches...',
+    'set-upstream': 'Setting upstream...',
+};
+export function VcBranchFlow({ onCancel, onComplete, request }) {
+    const branchMutation = useExecuteVcBranch();
+    useInput((_, key) => {
+        if (key.escape && !branchMutation.isPending)
+            onCancel();
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        branchMutation.mutate(request, {
+            onError(error) {
+                onComplete(`Failed: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                switch (result.action) {
+                    case 'create': {
+                        onComplete(`Created branch '${result.created}'.`);
+                        break;
+                    }
+                    case 'delete': {
+                        onComplete(`Deleted branch '${result.deleted}'.`);
+                        break;
+                    }
+                    case 'list': {
+                        onComplete(formatBranchList(result.branches));
+                        break;
+                    }
+                    case 'set-upstream': {
+                        onComplete(`Branch '${result.branch}' set up to track '${result.upstream}'.`);
+                        break;
+                    }
+                    // No default
+                }
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", LABELS[request.action]] }));
+}

package/dist/tui/features/vc/branch/utils/format-branch.d.ts

@@ -0,0 +1,4 @@
+import type { IVcBranchResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare function formatBranchList(branches: Extract<IVcBranchResponse, {
+    action: 'list';
+}>['branches']): string;

package/dist/tui/features/vc/branch/utils/format-branch.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+export function formatBranchList(branches) {
+    if (branches.length === 0)
+        return 'No branches found.';
+    return branches
+        .map((b) => {
+        const prefix = b.isCurrent ? '* ' : '  ';
+        const name = b.isRemote ? `remotes/${b.name}` : b.name;
+        return b.isCurrent ? `${prefix}${chalk.green(name)}` : `${prefix}${name}`;
+    })
+        .join('\n');
+}

package/dist/tui/features/vc/checkout/api/execute-vc-checkout.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcCheckoutRequest, type IVcCheckoutResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcCheckout: (request: IVcCheckoutRequest) => Promise<IVcCheckoutResponse>;
+type UseExecuteVcCheckoutOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcCheckout>;
+};
+export declare const useExecuteVcCheckout: ({ mutationConfig }?: UseExecuteVcCheckoutOptions) => import("@tanstack/react-query").UseMutationResult<IVcCheckoutResponse, Error, IVcCheckoutRequest, unknown>;
+export {};

package/dist/tui/features/vc/checkout/api/execute-vc-checkout.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 executeVcCheckout = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.CHECKOUT, request);
+};
+export const useExecuteVcCheckout = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcCheckout,
+});

package/dist/tui/features/vc/checkout/components/vc-checkout-flow.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { IVcCheckoutRequest } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcCheckoutFlowProps = CustomDialogCallbacks & {
+    request: IVcCheckoutRequest;
+};
+export declare function VcCheckoutFlow({ onCancel, onComplete, request }: VcCheckoutFlowProps): React.ReactNode;
+export {};

package/dist/tui/features/vc/checkout/components/vc-checkout-flow.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcCheckout } from '../api/execute-vc-checkout.js';
+export function VcCheckoutFlow({ onCancel, onComplete, request }) {
+    const checkoutMutation = useExecuteVcCheckout();
+    useInput((_, key) => {
+        if (key.escape && !checkoutMutation.isPending)
+            onCancel();
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        checkoutMutation.mutate(request, {
+            onError(error) {
+                onComplete(`Failed: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.created) {
+                    onComplete(`Switched to a new branch '${result.branch}'`);
+                }
+                else {
+                    onComplete(`Switched to branch '${result.branch}'`);
+                }
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Switching to branch '", request.branch, "'..."] }));
+}

package/dist/tui/features/vc/clone/api/execute-vc-clone.d.ts

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcCloneRequest, type IVcCloneResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcClone: (request: IVcCloneRequest) => Promise<IVcCloneResponse>;
+type UseExecuteVcCloneOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcClone>;
+};
+export declare const useExecuteVcClone: ({ mutationConfig }?: UseExecuteVcCloneOptions) => import("@tanstack/react-query").UseMutationResult<IVcCloneResponse, Error, IVcCloneRequest, unknown>;
+export {};

package/dist/tui/features/vc/clone/api/execute-vc-clone.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 executeVcClone = (request) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(VcEvents.CLONE, request);
+};
+export const useExecuteVcClone = ({ mutationConfig } = {}) => useMutation({
+    ...mutationConfig,
+    mutationFn: executeVcClone,
+});

package/dist/tui/features/vc/clone/components/vc-clone-flow.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+interface VcCloneFlowProps extends CustomDialogCallbacks {
+    url?: string;
+}
+export declare function VcCloneFlow({ onCancel, onComplete, url }: VcCloneFlowProps): React.ReactNode;
+export {};