byterover-cli 2.5.2 → 3.0.0

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 {};

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

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { VcEvents } 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 { useTransportStore } from '../../../../stores/transport-store.js';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcClone } from '../api/execute-vc-clone.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 VcCloneFlow({ onCancel, onComplete, url }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState(url ? 'cloning' : 'entering_url');
+    const [cloneUrl, setCloneUrl] = useState(url ?? null);
+    const [cloneError, setCloneError] = useState(null);
+    const [progressMessages, setProgressMessages] = useState([]);
+    const mutatedRef = useRef(false);
+    const cloneMutation = useExecuteVcClone();
+    useInput((_, key) => {
+        if (key.escape && !cloneMutation.isPending) {
+            onCancel();
+        }
+    });
+    useEffect(() => {
+        if (step !== 'cloning' || mutatedRef.current || !cloneUrl)
+            return;
+        mutatedRef.current = true;
+        const { apiClient } = useTransportStore.getState();
+        const unsub = apiClient?.on(VcEvents.CLONE_PROGRESS, (evt) => {
+            setProgressMessages((prev) => [...prev, evt.message]);
+        });
+        cloneMutation.mutate({ url: cloneUrl }, {
+            onError(err) {
+                unsub?.();
+                mutatedRef.current = false;
+                if (url) {
+                    onComplete(formatTransportError(err));
+                }
+                else {
+                    setCloneError(formatTransportError(err));
+                    setStep('entering_url');
+                }
+            },
+            onSuccess(result) {
+                unsub?.();
+                const label = result.teamName && result.spaceName ? `${result.teamName}/${result.spaceName}` : 'repository';
+                onComplete(`Cloned ${label} successfully.`);
+            },
+        });
+        return () => {
+            unsub?.();
+        };
+    }, [onComplete, step, cloneUrl, url]);
+    const handleUrlSubmit = useCallback((submittedUrl) => {
+        setCloneError(null);
+        setProgressMessages([]);
+        setCloneUrl(submittedUrl);
+        setStep('cloning');
+    }, []);
+    if (step === 'cloning') {
+        return (_jsxs(_Fragment, { children: [progressMessages.map((msg, idx) => (_jsx(Text, { children: msg }, idx))), _jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Cloning..."] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [cloneError && _jsx(Text, { color: colors.errorText, children: cloneError }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "To clone a space:" }), _jsxs(Text, { children: ['  ', "Go to ", _jsx(Text, { bold: true, children: getWebAppUrl() }), " \u2192 create or open a Space"] }), _jsxs(Text, { children: ['  ', "and copy the remote URL."] })] }), _jsx(InlineInput, { message: "Paste your remote URL:", onSubmit: handleUrlSubmit, validate: validateRemoteUrl })] }));
+}

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+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 { useExecuteVcCommit } from '../api/execute-vc-commit.js';
+export function VcCommitFlow({ message, onCancel, onComplete }) {
+    const commitMutation = useExecuteVcCommit();
+    useInput((_, key) => {
+        if (key.escape && !commitMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        commitMutation.mutate({ message }, {
+            onError(error) {
+                onComplete(`Failed to commit: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(`[${result.sha.slice(0, 7)}] ${result.message}`);
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Committing..."] }));
+}

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

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

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

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { VcConfigKey } from '../../../../../shared/transport/events/vc-events.js';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcConfigFlowProps = CustomDialogCallbacks & {
+    configKey: VcConfigKey;
+    value?: string;
+};
+export declare function VcConfigFlow({ configKey, onCancel, onComplete, value }: VcConfigFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,30 @@
+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 { useExecuteVcConfig } from '../api/execute-vc-config.js';
+export function VcConfigFlow({ configKey, onCancel, onComplete, value }) {
+    const configMutation = useExecuteVcConfig();
+    useInput((_, key) => {
+        if (key.escape && !configMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        configMutation.mutate({ key: configKey, value }, {
+            onError(error) {
+                onComplete(`Failed: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(`${result.key} = ${result.value}`);
+            },
+        });
+    }, []);
+    const action = value === undefined ? 'Getting' : 'Setting';
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " ", action, " ", configKey, "..."] }));
+}

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

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

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

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcFetchFlowProps = CustomDialogCallbacks & {
+    ref?: string;
+    remote?: string;
+};
+export declare function VcFetchFlow({ onCancel, onComplete, ref: refProp, remote }: VcFetchFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,75 @@
+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 { useExecuteVcFetch } from '../api/execute-vc-fetch.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 VcFetchFlow({ onCancel, onComplete, ref: refProp, remote }) {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('fetching');
+    const fetchMutation = useExecuteVcFetch();
+    const remoteMutation = useExecuteVcRemote();
+    useInput((_, key) => {
+        if (key.escape && !fetchMutation.isPending && !remoteMutation.isPending) {
+            onCancel();
+        }
+    });
+    const executeFetch = useCallback(() => {
+        fetchMutation.mutate({ ref: refProp, remote }, {
+            onError(error) {
+                if (getTransportErrorCode(error) === VcErrorCode.NO_REMOTE) {
+                    setStep('configuring_remote');
+                    return;
+                }
+                onComplete(`Failed to fetch: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                onComplete(`Fetched from ${result.remote}.`);
+            },
+        });
+    }, [fetchMutation, onComplete, refProp, remote]);
+    const fired = useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        executeFetch();
+    }, []);
+    const handleUrlSubmit = useCallback((url) => {
+        remoteMutation.mutate({ subcommand: 'add', url }, {
+            onError(error) {
+                onComplete(`Failed to add remote: ${formatTransportError(error)}`);
+            },
+            onSuccess() {
+                setStep('fetching');
+                executeFetch();
+            },
+        });
+    }, [executeFetch, 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" }), " Fetching..."] }));
+}

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

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * VcInitFlow Component
+ *
+ * Initializes the git repository in .brv/context-tree/ via VcHandler.
+ */
+import React from 'react';
+import type { CustomDialogCallbacks } from '../../../../types/commands.js';
+type VcInitFlowProps = CustomDialogCallbacks;
+export declare function VcInitFlow({ onCancel, onComplete }: VcInitFlowProps): React.ReactNode;
+export {};

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

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * VcInitFlow Component
+ *
+ * Initializes the git repository in .brv/context-tree/ via VcHandler.
+ */
+import { Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+import React, { useEffect } from 'react';
+import { formatTransportError } from '../../../../utils/error-messages.js';
+import { useExecuteVcInit } from '../api/execute-vc-init.js';
+export function VcInitFlow({ onCancel, onComplete }) {
+    const initMutation = useExecuteVcInit();
+    useInput((_, key) => {
+        if (key.escape && !initMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        initMutation.mutate(undefined, {
+            onError(error) {
+                onComplete(`Failed to initialize: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                const msg = result.reinitialized
+                    ? `Reinitialized Git repository in ${result.gitDir}`
+                    : `Initialized Git repository in ${result.gitDir}`;
+                onComplete(msg);
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Initializing git repository..."] }));
+}

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

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

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