byterover-cli 2.5.2 → 3.0.0

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { VcMergeAction } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcMergeFlowProps = CustomDialogCallbacks & {
+    action: VcMergeAction;
+    allowUnrelatedHistories?: boolean;
+    branch?: string;
+    message?: string;
+};
+export declare function VcMergeFlow({ action, allowUnrelatedHistories, branch, message, onCancel, onComplete }: VcMergeFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,72 @@
+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 { useExecuteVcMerge } from '../api/execute-vc-merge.js';
+export function VcMergeFlow({ action, allowUnrelatedHistories, branch, message, onCancel, onComplete }) {
+    const mergeMutation = useExecuteVcMerge();
+    useInput((_, key) => {
+        if (key.escape && !mergeMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        const request = { action, allowUnrelatedHistories, branch, message };
+        // For TUI --continue without message: send first to get defaultMessage, then commit with it
+        if (action === 'continue' && !message) {
+            mergeMutation.mutate(request, {
+                onError(error) {
+                    onComplete(`Failed to continue merge: ${formatTransportError(error)}`);
+                },
+                onSuccess(result) {
+                    // Got defaultMessage — now commit with it silently (TUI can't spawn editor)
+                    const commitMessage = result.defaultMessage ?? 'Merge commit';
+                    mergeMutation.mutate({ action: 'continue', message: commitMessage }, {
+                        onError(error) {
+                            onComplete(`Failed to continue merge: ${formatTransportError(error)}`);
+                        },
+                        onSuccess() {
+                            onComplete('Merge commit created.');
+                        },
+                    });
+                },
+            });
+            return;
+        }
+        mergeMutation.mutate(request, {
+            onError(error) {
+                onComplete(`Failed to ${action} merge: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.action === 'abort') {
+                    onComplete('Merge aborted.');
+                    return;
+                }
+                if (result.action === 'continue') {
+                    onComplete('Merge commit created.');
+                    return;
+                }
+                // action: 'merge'
+                if (result.alreadyUpToDate) {
+                    onComplete('Already up to date.');
+                }
+                else if (result.conflicts && result.conflicts.length > 0) {
+                    const conflictLines = result.conflicts
+                        .map((c) => `CONFLICT (${c.type}): ${c.path}`)
+                        .join('\n');
+                    onComplete(`${conflictLines}\nAutomatic merge failed; fix conflicts and then commit the result.`);
+                }
+                else {
+                    onComplete(`Merged branch '${branch}'.`);
+                }
+            },
+        });
+    }, []);
+    const statusText = action === 'abort' ? 'Aborting merge...' : action === 'continue' ? 'Continuing merge...' : `Merging ${branch}...`;
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", statusText] }));
+}

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

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcPullRequest, type IVcPullResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcPull: (request?: IVcPullRequest) => Promise<IVcPullResponse>;
+type UseExecuteVcPullOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcPull>;
+};
+export declare const useExecuteVcPull: ({ mutationConfig }?: UseExecuteVcPullOptions) => import("@tanstack/react-query").UseMutationResult<IVcPullResponse, Error, IVcPullRequest | undefined, unknown>;
+export {};

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

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcPullFlowProps = CustomDialogCallbacks & {
+    allowUnrelatedHistories?: boolean;
+    branch?: string;
+    remote?: string;
+};
+export declare function VcPullFlow({ allowUnrelatedHistories, branch, onCancel, onComplete, remote }: VcPullFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcErrorCode } from '../../../../../shared/transport/events/vc-events.js';
+import { InlineInput } from '../../../../components/inline-prompts/inline-input.js';
+import { useTheme } from '../../../../hooks/index.js';
+import { getWebAppUrl } from '../../../../lib/environment.js';
+import { formatTransportError, getTransportErrorCode } from '../../../../utils/error-messages.js';
+import { useExecuteVcRemote } from '../../remote/api/execute-vc-remote.js';
+import { useExecuteVcPull } from '../api/execute-vc-pull.js';
+function validateRemoteUrl(value) {
+    if (!value)
+        return 'URL is required';
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:') {
+            return 'URL must start with https://';
+        }
+        return true;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+export function VcPullFlow({ allowUnrelatedHistories, branch, onCancel, onComplete, remote }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('pulling');
+    const pullMutation = useExecuteVcPull();
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !pullMutation.isPending && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const executePull = useCallback(() => {
+        pullMutation.mutate({ allowUnrelatedHistories, branch, remote }, {
+            onError(error) {
+                if (getTransportErrorCode(error) === VcErrorCode.NO_REMOTE) {
+                    setStep('configuring_remote');
+                    return;
+                }
+                onComplete(`Failed to pull: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.conflicts && result.conflicts.length > 0) {
+                    const conflictLines = result.conflicts
+                        .map((c) => `CONFLICT (${c.type}): ${c.path}`)
+                        .join('\n');
+                    onComplete(`${conflictLines}\nAutomatic merge failed; fix conflicts and then commit the result.`);
+                }
+                else {
+                    onComplete(result.alreadyUpToDate ? 'Already up to date.' : `Pulled from origin/${result.branch}.`);
+                }
+            },
+        });
+    }, [allowUnrelatedHistories, branch, onComplete, pullMutation, remote]);
+    const fired = useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        executePull();
+    }, []);
+    const handleUrlSubmit = useCallback((url) => {
+        remoteMutation.mutate({ subcommand: 'add', url }, {
+            onError(error) {
+                onComplete(`Failed to add remote: ${formatTransportError(error)}`);
+            },
+            onSuccess() {
+                setStep('pulling');
+                executePull();
+            },
+        });
+    }, [executePull, onComplete, remoteMutation]);
+    if (step === 'configuring_remote') {
+        if (remoteMutation.isPending) {
+            return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Adding remote..."] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.warning, children: "No remote configured." }), _jsx(Text, {}), _jsx(Text, { children: "To connect to cloud:" }), _jsxs(Text, { children: ["  Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsx(Text, { children: "  and copy the remote URL." })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+    }
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Pulling..."] }));
+}

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

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

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

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcPushFlowProps = CustomDialogCallbacks & {
+    branch?: string;
+    setUpstream?: boolean;
+};
+export declare function VcPushFlow({ branch, onCancel, onComplete, setUpstream }: VcPushFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcErrorCode } from '../../../../../shared/transport/events/vc-events.js';
+import { InlineInput } from '../../../../components/inline-prompts/inline-input.js';
+import { useTheme } from '../../../../hooks/index.js';
+import { getWebAppUrl } from '../../../../lib/environment.js';
+import { formatTransportError, getTransportErrorCode } from '../../../../utils/error-messages.js';
+import { useExecuteVcRemote } from '../../remote/api/execute-vc-remote.js';
+import { useExecuteVcPush } from '../api/execute-vc-push.js';
+function validateRemoteUrl(value) {
+    if (!value)
+        return 'URL is required';
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:') {
+            return 'URL must start with https://';
+        }
+        return true;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+export function VcPushFlow({ branch, onCancel, onComplete, setUpstream }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('pushing');
+    const pushMutation = useExecuteVcPush();
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !pushMutation.isPending && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const executePush = useCallback((overrideSetUpstream) => {
+        pushMutation.mutate({ branch, setUpstream: overrideSetUpstream ?? setUpstream }, {
+            onError(error) {
+                if (getTransportErrorCode(error) === VcErrorCode.NO_REMOTE) {
+                    setStep('configuring_remote');
+                    return;
+                }
+                onComplete(`Failed to push: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.alreadyUpToDate) {
+                    onComplete('Everything up-to-date.');
+                }
+                else if (result.upstreamSet) {
+                    onComplete(`Pushed to origin/${result.branch} and set upstream.`);
+                }
+                else {
+                    onComplete(`Pushed to origin/${result.branch}.`);
+                }
+            },
+        });
+    }, [branch, onComplete, pushMutation, setUpstream]);
+    const fired = useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        executePush();
+    }, []);
+    const handleUrlSubmit = useCallback((url) => {
+        remoteMutation.mutate({ subcommand: 'add', url }, {
+            onError(error) {
+                onComplete(`Failed to add remote: ${formatTransportError(error)}`);
+            },
+            onSuccess() {
+                setStep('pushing');
+                executePush(true);
+            },
+        });
+    }, [executePush, onComplete, remoteMutation]);
+    if (step === 'configuring_remote') {
+        if (remoteMutation.isPending) {
+            return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Adding remote..."] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.warning, children: "No remote configured." }), _jsx(Text, {}), _jsx(Text, { children: "To connect to cloud:" }), _jsxs(Text, { children: ["  Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsx(Text, { children: "  and copy the remote URL." })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+    }
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", branch ? `Pushing to origin/${branch}...` : 'Pushing...'] }));
+}

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

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

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

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { VcRemoteSubcommand } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcRemoteFlowProps = CustomDialogCallbacks & {
+    subcommand: VcRemoteSubcommand;
+    url?: string;
+};
+export declare function VcRemoteFlow({ onCancel, onComplete, subcommand, url }: VcRemoteFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,42 @@
+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 { useExecuteVcRemote } from '../api/execute-vc-remote.js';
+const LABELS = {
+    add: 'Adding remote...',
+    'set-url': 'Updating remote...',
+    show: 'Fetching remote...',
+};
+export function VcRemoteFlow({ onCancel, onComplete, subcommand, url }) {
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        remoteMutation.mutate({ subcommand, url }, {
+            onError(error) {
+                onComplete(`Failed: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.action === 'show') {
+                    onComplete(result.url ? `origin: ${result.url}` : 'No remote configured.');
+                }
+                else if (result.action === 'add') {
+                    onComplete(`Remote 'origin' set to ${result.url}.`);
+                }
+                else {
+                    onComplete(`Remote 'origin' updated to ${result.url}.`);
+                }
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", LABELS[subcommand]] }));
+}

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

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

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

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { VcResetMode } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcResetFlowProps = CustomDialogCallbacks & {
+    filePaths?: string[];
+    mode?: VcResetMode;
+    ref?: string;
+};
+export declare function VcResetFlow({ filePaths, mode, onCancel, onComplete, ref }: VcResetFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, useInput } 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 { useExecuteVcReset } from '../api/execute-vc-reset.js';
+export function VcResetFlow({ filePaths, mode, onCancel, onComplete, ref }) {
+    const needsConfirm = mode === 'hard';
+    const [step, setStep] = useState(needsConfirm ? 'confirm' : 'executing');
+    const resetMutation = useExecuteVcReset();
+    useInput((_, key) => {
+        if (key.escape && !resetMutation.isPending) {
+            onCancel();
+        }
+    });
+    useEffect(() => {
+        if (step !== 'executing')
+            return;
+        const request = filePaths
+            ? { filePaths }
+            : { mode: mode ?? 'mixed', ref };
+        resetMutation.mutate(request, {
+            onError(error) {
+                onComplete(`Failed to reset: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                if (result.filesUnstaged === undefined) {
+                    if (result.headSha) {
+                        onComplete(`HEAD is now at ${result.headSha.slice(0, 7)}`);
+                    }
+                    else {
+                        onComplete(''); // Empty repo — silent no-op, matches git
+                    }
+                }
+                else if (result.filesUnstaged === 0) {
+                    onComplete('Nothing to unstage.');
+                }
+                else {
+                    onComplete(`Unstaged ${result.filesUnstaged} file(s).`);
+                }
+            },
+        });
+    }, [step]);
+    if (step === 'confirm') {
+        return (_jsx(InlineConfirm, { default: false, message: `This will discard all changes and reset to ${ref ?? 'HEAD'}. Continue`, onConfirm: (confirmed) => {
+                if (confirmed) {
+                    setStep('executing');
+                }
+                else {
+                    onComplete('Reset cancelled.');
+                }
+            } }));
+    }
+    const label = filePaths
+        ? `Unstaging ${filePaths.join(' ')}...`
+        : mode === 'soft'
+            ? `Soft resetting to ${ref ?? 'HEAD'}...`
+            : mode === 'hard'
+                ? `Hard resetting to ${ref ?? 'HEAD'}...`
+                : 'Unstaging all files...';
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", label] }));
+}

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

@@ -0,0 +1,8 @@
+import type { MutationConfig } from '../../../../lib/react-query.js';
+import { type IVcStatusResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare const executeVcStatus: () => Promise<IVcStatusResponse>;
+type UseExecuteVcStatusOptions = {
+    mutationConfig?: MutationConfig<typeof executeVcStatus>;
+};
+export declare const useExecuteVcStatus: ({ mutationConfig }?: UseExecuteVcStatusOptions) => import("@tanstack/react-query").UseMutationResult<IVcStatusResponse, Error, undefined, unknown>;
+export {};

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

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

@@ -0,0 +1,10 @@
+/**
+ * VcStatusFlow Component
+ *
+ * Shows git status of the context tree via VcHandler.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcStatusFlowProps = CustomDialogCallbacks;
+export declare function VcStatusFlow({ onCancel, onComplete }: VcStatusFlowProps): React.ReactNode;
+export {};