byterover-cli 3.8.3 → 3.10.0

package/dist/server/infra/transport/handlers/vc-handler.js

@@ -32,6 +32,29 @@ const FIELD_MAP = {
     'user.email': 'email',
     'user.name': 'name',
 };
+function inferStatus(oldExists, newExists) {
+    if (!oldExists && newExists)
+        return 'added';
+    if (oldExists && !newExists)
+        return 'deleted';
+    return 'modified';
+}
+function resolveDiffSides(mode) {
+    switch (mode.kind) {
+        case 'range': {
+            return { from: { commitish: mode.from }, to: { commitish: mode.to } };
+        }
+        case 'ref-vs-worktree': {
+            return { from: { commitish: mode.ref }, to: 'WORKDIR' };
+        }
+        case 'staged': {
+            return { from: { commitish: 'HEAD' }, to: 'STAGE' };
+        }
+        case 'unstaged': {
+            return { from: 'STAGE', to: 'WORKDIR' };
+        }
+    }
+}
 /**
  * Handles vc:* events (Version Control commands).
  */
@@ -96,6 +119,35 @@ export class VcHandler {
         }
         return 'Run: brv vc config user.name <value> and brv vc config user.email <value>.';
     }
+    /**
+     * Builds a single diff entry for a changed file, or `undefined` when either required side
+     * is absent/binary (the caller filters these out to keep binaries out of diff output).
+     */
+    async buildDiffFile(params) {
+        const { directory, from, path, status, to } = params;
+        const [oldSide, newSide] = await Promise.all([
+            status === 'added' ? undefined : this.readSideEntry(directory, from, path),
+            status === 'deleted' ? undefined : this.readSideEntry(directory, to, path),
+        ]);
+        if (status !== 'added' && !oldSide)
+            return undefined;
+        if (status !== 'deleted' && !newSide)
+            return undefined;
+        const binary = (oldSide?.binary ?? false) || (newSide?.binary ?? false);
+        const result = {
+            newContent: binary ? '' : (newSide?.content ?? ''),
+            oldContent: binary ? '' : (oldSide?.content ?? ''),
+            path,
+            status,
+        };
+        if (oldSide)
+            result.oldOid = oldSide.oid;
+        if (newSide)
+            result.newOid = newSide.oid;
+        if (binary)
+            result.binary = true;
+        return result;
+    }
     buildNoRemoteMessage(nextStep) {
         return (`No remote configured.\n\nTo connect to cloud:\n` +
             `  1. Go to ${this.webAppUrl} → create or open a Space\n` +
@@ -106,7 +158,7 @@ export class VcHandler {
     async computeDiff(directory, path, side) {
         if (side === 'staged') {
             const [head, stage] = await Promise.all([
-                this.gitService.getBlobContent({ directory, path, ref: 'HEAD' }),
+                this.gitService.getBlobContent({ directory, path, ref: { commitish: 'HEAD' } }),
                 this.gitService.getBlobContent({ directory, path, ref: 'STAGE' }),
             ]);
             return { newContent: stage ?? '', oldContent: head ?? '', path };
@@ -480,19 +532,63 @@ export class VcHandler {
         if (!gitInitialized) {
             throw new VcError('ByteRover version control not initialized.', VcErrorCode.GIT_NOT_INITIALIZED);
         }
+        // Mode-based call (CLI/TUI): auto-discover changed files + return full IVcDiffFile entries.
+        // Binary or unreadable files are dropped by buildDiffFile (returns undefined).
+        if ('mode' in data) {
+            const { from, to } = resolveDiffSides(data.mode);
+            try {
+                const changed = await this.gitService.listChangedFiles({ directory, from, to });
+                const entries = await Promise.all(changed.map((change) => this.buildDiffFile({ directory, from, path: change.path, status: change.status, to })));
+                const diffs = entries.filter((d) => d !== undefined);
+                return { diffs, mode: data.mode };
+            }
+            catch (error) {
+                const classified = classifyIsomorphicGitError(error, VcErrorCode.INVALID_REF);
+                if (classified)
+                    throw classified;
+                throw error;
+            }
+        }
+        // WebUI call: caller-supplied paths + side. Status is derived from blob presence,
+        // so an empty-blob edit is correctly reported as `modified`, not `added`.
         const { paths, side } = data;
         if (side === 'staged') {
             const [head, stage] = await Promise.all([
-                this.gitService.getBlobContents({ directory, paths, ref: 'HEAD' }),
+                this.gitService.getBlobContents({ directory, paths, ref: { commitish: 'HEAD' } }),
                 this.gitService.getBlobContents({ directory, paths, ref: 'STAGE' }),
             ]);
-            const diffs = paths.map((path) => ({ newContent: stage[path] ?? '', oldContent: head[path] ?? '', path }));
+            const diffs = paths.map((path) => {
+                const oldBlob = head[path];
+                const newBlob = stage[path];
+                return {
+                    newContent: newBlob ?? '',
+                    oldContent: oldBlob ?? '',
+                    path,
+                    status: inferStatus(oldBlob !== undefined, newBlob !== undefined),
+                };
+            });
             return { diffs };
         }
         // unstaged: compare index (old) against working tree (new)
         const stage = await this.gitService.getBlobContents({ directory, paths, ref: 'STAGE' });
-        const workingTree = await Promise.all(paths.map((path) => fs.promises.readFile(join(directory, path), 'utf8').catch(() => '')));
-        const diffs = paths.map((path, i) => ({ newContent: workingTree[i], oldContent: stage[path] ?? '', path }));
+        const workingTree = await Promise.all(paths.map(async (path) => {
+            try {
+                return await fs.promises.readFile(join(directory, path), 'utf8');
+            }
+            catch {
+                return undefined;
+            }
+        }));
+        const diffs = paths.map((path, i) => {
+            const oldBlob = stage[path];
+            const newFile = workingTree[i];
+            return {
+                newContent: newFile ?? '',
+                oldContent: oldBlob ?? '',
+                path,
+                status: inferStatus(oldBlob !== undefined, newFile !== undefined),
+            };
+        });
         return { diffs };
     }
     async handleDiscard(data, clientId) {
@@ -506,15 +602,13 @@ export class VcHandler {
         // Prefer index blob (preserves staged changes); fall back to HEAD; else delete (untracked).
         const [stage, head] = await Promise.all([
             this.gitService.getBlobContents({ directory, paths: filePaths, ref: 'STAGE' }),
-            this.gitService.getBlobContents({ directory, paths: filePaths, ref: 'HEAD' }),
+            this.gitService.getBlobContents({ directory, paths: filePaths, ref: { commitish: 'HEAD' } }),
         ]);
         const results = await Promise.all(filePaths.map(async (path) => {
             const target = stage[path] ?? head[path];
             const absolutePath = join(directory, path);
             try {
-                await (target === undefined
-                    ? fs.promises.unlink(absolutePath)
-                    : fs.promises.writeFile(absolutePath, target));
+                await (target === undefined ? fs.promises.unlink(absolutePath) : fs.promises.writeFile(absolutePath, target));
                 return true;
             }
             catch {
@@ -820,6 +914,25 @@ export class VcHandler {
             const url = await this.gitService.getRemoteUrl({ directory, remote: 'origin' });
             return { action: 'show', url: url ? maskCredentialsInUrl(url) : undefined };
         }
+        if (data.subcommand === 'remove') {
+            const existingUrl = await this.gitService.getRemoteUrl({ directory, remote: 'origin' });
+            if (!existingUrl) {
+                throw new VcError("No remote 'origin' to remove.", VcErrorCode.NO_REMOTE);
+            }
+            // Clear config before removing the remote so a mid-way failure leaves a retry-friendly state:
+            // if removeRemote throws, config is already cleared and remote is still present, so
+            // re-running `remove` will retry removeRemote and succeed. The reverse order leaves the
+            // remote gone but config stale, and the next `remove` fails with NO_REMOTE — unrecoverable.
+            const existingConfig = await this.projectConfigStore.read(projectPath);
+            if (existingConfig) {
+                await this.projectConfigStore.write(existingConfig.withoutSpace(), projectPath);
+            }
+            await this.gitService.removeRemote({ directory, remote: 'origin' });
+            return { action: 'remove' };
+        }
+        if (data.subcommand !== 'add' && data.subcommand !== 'set-url') {
+            throw new VcError('Unknown remote subcommand.', VcErrorCode.INVALID_ACTION);
+        }
         if (!data.url) {
             throw new VcError('URL is required.', VcErrorCode.INVALID_REMOTE_URL);
         }
@@ -981,6 +1094,27 @@ export class VcHandler {
             untracked: gitStatus.files.filter((f) => f.status === 'untracked').map((f) => f.path),
         };
     }
+    /**
+     * Reads a diff side's content + short oid in a single pass. Returns `undefined`
+     * only when the blob is absent on disk / at the ref. Binary content (NUL byte)
+     * is marked via `binary: true` so the caller can emit `Binary files ... differ`.
+     */
+    async readSideEntry(directory, side, path) {
+        if (side === 'WORKDIR') {
+            let buf;
+            try {
+                buf = await fs.promises.readFile(join(directory, path));
+            }
+            catch {
+                return undefined;
+            }
+            const oid = await this.gitService.hashBlob(buf);
+            if (buf.includes(0))
+                return { binary: true, content: '', oid };
+            return { content: buf.toString('utf8'), oid };
+        }
+        return this.gitService.getTextBlob({ directory, path, ref: side });
+    }
     /**
      * Resolve clone request data into a clean cogit URL + team/space info.
      * Accepts either a URL or explicit teamName/spaceName.

package/dist/server/infra/transport/socket-io-transport-server.js

@@ -81,14 +81,9 @@ export class SocketIOTransportServer {
         this.disconnectionHandlers.push(handler);
     }
     onRequest(event, handler) {
-        const { io } = this;
-        if (!io) {
-            throw new TransportServerNotStartedError('onRequest');
-        }
-        // Store handler wrapped to accept unknown types (avoids type assertion)
+        // Pre-start registration is supported: start()'s connection handler iterates this.requestHandlers.
         const wrappedHandler = (data, clientId) => handler(data, clientId);
         this.requestHandlers.set(event, wrappedHandler);
-        // Apply handler to all existing sockets
         for (const socket of this.sockets.values()) {
             this.registerEventHandler(socket, event, wrappedHandler);
         }

package/dist/server/infra/webui/webui-middleware.js

@@ -19,7 +19,12 @@ export function createWebUiMiddleware({ getConfig, webuiDistDir }) {
             "connect-src 'self' ws: wss:",
             "font-src 'self' data: https://fonts.gstatic.com",
             "frame-ancestors 'none'",
-            "img-src 'self' data:",
+            // `img-src https:` is deliberately broad: user avatars come from an
+            // open-ended set of OAuth provider CDNs (Google, GitHub, Gravatar,
+            // self-hosted identity providers, …) that can't be enumerated ahead
+            // of time. Images can't execute code, so the attack surface is just
+            // pixel exfiltration / tracking, which we accept for this use case.
+            "img-src 'self' data: https:",
             "object-src 'none'",
             "script-src 'self'",
             "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com",

package/dist/shared/transport/events/config-events.d.ts

@@ -5,6 +5,7 @@ export declare const ConfigEvents: {
     readonly PROJECT_CHANGED: "config:projectChanged";
 };
 export interface ConfigGetEnvironmentResponse {
+    gitRemoteBaseUrl: string;
     iamBaseUrl: string;
     isDevelopment: boolean;
     webAppUrl: string;

package/dist/shared/transport/events/index.d.ts

@@ -130,6 +130,7 @@ export declare const AllEventGroups: readonly [{
     readonly SWITCHED: "session:switched";
 }, {
     readonly GET: "locations:get";
+    readonly REVEAL: "locations:reveal";
 }, {
     readonly ADD: "source:add";
     readonly LIST: "source:list";

package/dist/shared/transport/events/locations-events.d.ts

@@ -1,7 +1,14 @@
 import type { ProjectLocationDTO } from '../types/dto.js';
 export declare const LocationsEvents: {
     readonly GET: "locations:get";
+    readonly REVEAL: "locations:reveal";
 };
 export interface LocationsGetResponse {
     locations: ProjectLocationDTO[];
 }
+export interface LocationsRevealRequest {
+    projectPath: string;
+}
+export interface LocationsRevealResponse {
+    projectPath: string;
+}

package/dist/shared/transport/events/locations-events.js

@@ -1,3 +1,4 @@
 export const LocationsEvents = {
     GET: 'locations:get',
+    REVEAL: 'locations:reveal',
 };

package/dist/shared/transport/events/vc-events.d.ts

@@ -155,8 +155,9 @@ export interface IVcLogResponse {
     }>;
     currentBranch?: string;
 }
-export type VcRemoteSubcommand = 'add' | 'set-url' | 'show';
+export type VcRemoteSubcommand = 'add' | 'remove' | 'set-url' | 'show';
 export declare const VC_REMOTE_SUBCOMMANDS: readonly string[];
+export declare const VC_REMOTE_SUBCOMMAND_REQUIRES_URL: Record<VcRemoteSubcommand, boolean>;
 export declare function isVcRemoteSubcommand(value: string): value is VcRemoteSubcommand;
 export interface IVcRemoteRequest {
     subcommand: VcRemoteSubcommand;
@@ -280,15 +281,65 @@ export interface IVcDiffResponse {
     path: string;
 }
 /**
- * Batched diff — returns diffs for multiple paths on the same side in one round-trip.
- * Preserves the order of the input `paths`.
+ * Batched diff — returns diffs for multiple files in one round-trip.
+ *
+ * Discriminated union of two mutually exclusive request shapes:
+ * - WebUI: `{paths, side}` — caller supplies the paths, server returns raw content pairs.
+ * - CLI/TUI: `{mode}` — server auto-discovers changed files, returns full `IVcDiffFile`
+ *   entries (status + oids). Binary files are filtered out.
+ *
+ * The union form guarantees callers can't accidentally mix the two shapes (type error).
  */
-export interface IVcDiffsRequest {
+export type IVcDiffsRequest = {
+    mode: VcDiffMode;
+} | {
     paths: string[];
     side: VcDiffSide;
+};
+/**
+ * Diff modes for `brv vc diff` / `/vc diff`. Mirrors the four diff modes from `git diff`:
+ * - unstaged       → STAGE → WORKDIR (tracked files only; matches `git diff` no args)
+ * - staged         → HEAD → STAGE   (matches `git diff --staged`)
+ * - ref-vs-worktree → <commit|branch> → WORKDIR (matches `git diff <ref>`)
+ * - range          → <ref1> → <ref2>           (matches `git diff <ref1>..<ref2>`)
+ */
+export type VcDiffMode = {
+    from: string;
+    kind: 'range';
+    to: string;
+} | {
+    kind: 'ref-vs-worktree';
+    ref: string;
+} | {
+    kind: 'staged';
+} | {
+    kind: 'unstaged';
+};
+export type VcDiffFileStatus = 'added' | 'deleted' | 'modified';
+/**
+ * Per-file diff entry. Extends `IVcDiffResponse` with status + oid.
+ * Binary files (NUL byte on either side) are filtered out of the response upstream,
+ * so consumers only ever see text content here.
+ *
+ * Legacy (WebUI) consumers read `oldContent`/`newContent`/`path` only; the extra
+ * fields are forward-compatible extras they ignore.
+ */
+export interface IVcDiffFile {
+    /** True when either side is binary (contains a NUL byte). Content fields are empty. */
+    binary?: boolean;
+    newContent: string;
+    /** 7-char short oid; omitted for deleted files. */
+    newOid?: string;
+    oldContent: string;
+    /** 7-char short oid; omitted for added files. */
+    oldOid?: string;
+    path: string;
+    status: VcDiffFileStatus;
 }
 export interface IVcDiffsResponse {
-    diffs: IVcDiffResponse[];
+    diffs: IVcDiffFile[];
+    /** Echoed when the request used `mode`; absent for legacy calls. */
+    mode?: VcDiffMode;
 }
 /**
  * Discards unstaged changes in the working tree.

package/dist/shared/transport/events/vc-events.js

@@ -62,9 +62,16 @@ export function isVcConfigKey(key) {
 }
 export const VC_REMOTE_SUBCOMMANDS = [
     'add',
+    'remove',
     'set-url',
     'show',
 ];
+export const VC_REMOTE_SUBCOMMAND_REQUIRES_URL = {
+    add: true,
+    remove: false,
+    'set-url': true,
+    show: false,
+};
 export function isVcRemoteSubcommand(value) {
     return VC_REMOTE_SUBCOMMANDS.includes(value);
 }

package/dist/shared/types/agent.d.ts

@@ -1,6 +1,6 @@
 /**
  * Array of all supported Agents.
  */
-export declare const AGENT_VALUES: readonly ["Amp", "Antigravity", "Auggie CLI", "Augment Code", "Claude Code", "Claude Desktop", "Cline", "Codex", "Cursor", "Gemini CLI", "Github Copilot", "Junie", "Kilo Code", "Kiro", "OpenClaw", "OpenCode", "Qoder", "Qwen Code", "Roo Code", "Trae.ai", "Warp", "Windsurf", "Zed"];
+export declare const AGENT_VALUES: readonly ["Amp", "Antigravity", "Auggie CLI", "Augment Code", "Claude Code", "Claude Desktop", "Cline", "Codex", "Cursor", "Gemini CLI", "Github Copilot", "Junie", "Kilo Code", "Kiro", "OpenClaude", "OpenClaw", "OpenCode", "Qoder", "Qwen Code", "Roo Code", "Trae.ai", "Warp", "Windsurf", "Zed"];
 export type Agent = (typeof AGENT_VALUES)[number];
 export declare const CLAUDE_DESKTOP: Agent;

package/dist/shared/types/agent.js

@@ -16,6 +16,7 @@ export const AGENT_VALUES = [
     'Junie',
     'Kilo Code',
     'Kiro',
+    'OpenClaude',
     'OpenClaw',
     'OpenCode',
     'Qoder',

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

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

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import { VcDiffFlow } from '../../vc/diff/components/vc-diff-flow.js';
+import { parseMode } from '../../vc/diff/utils/parse-mode.js';
+import { Args, Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const vcDiffArgs = {
+    ref: Args.string({ description: 'commit, branch, or <ref1>..<ref2> range' }),
+};
+const vcDiffFlags = {
+    staged: Flags.boolean({ default: false, description: 'Show staged changes (HEAD vs index)' }),
+};
+export const vcDiffSubCommand = {
+    async action(_context, args) {
+        const parsed = await parseReplArgs(args, { args: vcDiffArgs, flags: vcDiffFlags, strict: false });
+        const mode = parseMode(parsed.args.ref, parsed.flags.staged ?? false);
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(VcDiffFlow, { mode, onCancel, onComplete }),
+        };
+    },
+    args: [{ description: 'commit, branch, or <ref1>..<ref2> range', name: 'ref' }],
+    description: 'Show changes between commits, the index, or the working tree',
+    flags: toCommandFlags(vcDiffFlags),
+    name: 'diff',
+};

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

@@ -1,11 +1,11 @@
 import React from 'react';
-import { isVcRemoteSubcommand } from '../../../../shared/transport/events/vc-events.js';
+import { isVcRemoteSubcommand, VC_REMOTE_SUBCOMMAND_REQUIRES_URL } from '../../../../shared/transport/events/vc-events.js';
 import { getGitRemoteBaseUrl } from '../../../lib/environment.js';
 import { VcRemoteFlow } from '../../vc/remote/components/vc-remote-flow.js';
 import { Args, parseReplArgs } from '../utils/arg-parser.js';
 /* eslint-disable perfectionist/sort-objects -- positional order matters: subcommand, name, url */
 const vcRemoteArgs = {
-    subcommand: Args.string({ description: 'Subcommand: add | set-url (omit to show current remote)' }),
+    subcommand: Args.string({ description: 'Subcommand: add | set-url | remove (omit to show current remote)' }),
     name: Args.string({ description: 'Remote name (e.g. origin)' }),
     url: Args.string({ description: `Remote URL (e.g. ${getGitRemoteBaseUrl()}/<team>/<space>.git)` }),
 };
@@ -21,15 +21,24 @@ export const vcRemoteSubCommand = {
         }
         if (!isVcRemoteSubcommand(rawSubcommand)) {
             const errorMsg = {
-                content: `Unknown subcommand '${rawSubcommand}'. Usage: /vc remote [add|set-url] <name> <url>`,
+                content: `Unknown subcommand '${rawSubcommand}'. Usage: /vc remote [add|set-url|remove] <name> [url]`,
                 messageType: 'error',
                 type: 'message',
             };
             return errorMsg;
         }
-        if (!name || !url) {
+        if (rawSubcommand === 'show') {
+            return {
+                render: ({ onCancel, onComplete }) => React.createElement(VcRemoteFlow, { onCancel, onComplete, subcommand: 'show' }),
+            };
+        }
+        const requiresUrl = VC_REMOTE_SUBCOMMAND_REQUIRES_URL[rawSubcommand];
+        if (!name || (requiresUrl && !url)) {
+            const usage = requiresUrl
+                ? `Usage: /vc remote ${rawSubcommand} <name> <url>`
+                : `Usage: /vc remote ${rawSubcommand} <name>`;
             const errorMsg = {
-                content: `Usage: /vc remote ${rawSubcommand} <name> <url>`,
+                content: usage,
                 messageType: 'error',
                 type: 'message',
             };
@@ -48,9 +57,9 @@ export const vcRemoteSubCommand = {
         };
     },
     args: [
-        { description: 'Subcommand: add | set-url (omit to show current remote)', name: 'subcommand' },
+        { description: 'Subcommand: add | set-url | remove (omit to show current remote)', name: 'subcommand' },
         { description: 'Remote name (e.g. origin)', name: 'name' },
-        { description: 'Remote URL', name: 'url' },
+        { description: 'Remote URL (required for add | set-url)', name: 'url' },
     ],
     description: 'Manage remote origin for ByteRover version control',
     name: 'remote',

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

@@ -4,6 +4,7 @@ import { vcCheckoutSubCommand } from './vc-checkout.js';
 import { vcCloneSubCommand } from './vc-clone.js';
 import { vcCommitSubCommand } from './vc-commit.js';
 import { vcConfigSubCommand } from './vc-config.js';
+import { vcDiffSubCommand } from './vc-diff.js';
 import { vcFetchSubCommand } from './vc-fetch.js';
 import { vcInitSubCommand } from './vc-init.js';
 import { vcLogSubCommand } from './vc-log.js';
@@ -26,6 +27,7 @@ export const vcCommand = {
         vcPullSubCommand,
         vcPushSubCommand,
         vcStatusSubCommand,
+        vcDiffSubCommand,
         vcLogSubCommand,
         vcMergeSubCommand,
         vcBranchSubCommand,

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+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 { useExecuteVcDiff } from '../api/execute-vc-diff.js';
+import { formatDiff } from '../utils/format-diff.js';
+export function VcDiffFlow({ mode, onCancel, onComplete }) {
+    const diffMutation = useExecuteVcDiff();
+    useInput((_, key) => {
+        if (key.escape && !diffMutation.isPending) {
+            onCancel();
+        }
+    });
+    const fired = React.useRef(false);
+    useEffect(() => {
+        if (fired.current)
+            return;
+        fired.current = true;
+        diffMutation.mutate({ mode }, {
+            onError(error) {
+                onComplete(`Failed to compute diff: ${formatTransportError(error)}`);
+            },
+            onSuccess(result) {
+                const text = formatDiff(result);
+                onComplete(text.length === 0 ? 'No changes.' : text.replace(/\n$/, ''));
+            },
+        });
+    }, []);
+    return (_jsxs(Text, { children: [_jsx(Spinner, { type: "dots" }), " Computing diff..."] }));
+}

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

@@ -0,0 +1,2 @@
+import type { IVcDiffsResponse } from '../../../../../shared/transport/events/vc-events.js';
+export declare function formatDiff(response: IVcDiffsResponse): string;

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

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import { structuredPatch } from 'diff';
+export function formatDiff(response) {
+    if (response.diffs.length === 0)
+        return '';
+    return response.diffs.map((file) => formatFile(file)).join('');
+}
+function formatFile(f) {
+    const aPath = f.status === 'added' ? '/dev/null' : `a/${f.path}`;
+    const bPath = f.status === 'deleted' ? '/dev/null' : `b/${f.path}`;
+    const lines = [chalk.bold(`diff --git a/${f.path} b/${f.path}`)];
+    if (f.status === 'added') {
+        lines.push(chalk.bold('new file mode 100644'));
+        if (f.newOid)
+            lines.push(chalk.bold(`index 0000000..${f.newOid}`));
+    }
+    else if (f.status === 'deleted') {
+        lines.push(chalk.bold('deleted file mode 100644'));
+        if (f.oldOid)
+            lines.push(chalk.bold(`index ${f.oldOid}..0000000`));
+    }
+    else if (f.oldOid && f.newOid) {
+        lines.push(chalk.bold(`index ${f.oldOid}..${f.newOid} 100644`));
+    }
+    if (f.binary) {
+        lines.push(`Binary files ${aPath} and ${bPath} differ`);
+        return lines.join('\n') + '\n';
+    }
+    const patch = structuredPatch(f.path, f.path, f.oldContent, f.newContent, '', '', { context: 3 });
+    // Skip `---`/`+++` when there are no hunks (e.g. empty file added/deleted).
+    // Matches `git diff` which omits these lines when there's nothing to show.
+    if (patch.hunks.length === 0) {
+        return lines.join('\n') + '\n';
+    }
+    // Append a tab after paths containing spaces/tabs so the unified-diff parser
+    // can unambiguously locate the path end. Matches `git diff` behavior.
+    const aHeader = hasWhitespace(f.path) && f.status !== 'added' ? `${aPath}\t` : aPath;
+    const bHeader = hasWhitespace(f.path) && f.status !== 'deleted' ? `${bPath}\t` : bPath;
+    lines.push(chalk.bold(`--- ${aHeader}`), chalk.bold(`+++ ${bHeader}`));
+    const oldLines = f.oldContent.split('\n');
+    for (const hunk of patch.hunks) {
+        const header = `@@ -${formatHunkRange(hunk.oldStart, hunk.oldLines)} +${formatHunkRange(hunk.newStart, hunk.newLines)} @@`;
+        const context = findHunkContext(oldLines, hunk.oldStart);
+        lines.push(chalk.cyan(context ? `${header} ${context}` : header));
+        for (const line of hunk.lines) {
+            if (line.startsWith('+'))
+                lines.push(chalk.green(line));
+            else if (line.startsWith('-'))
+                lines.push(chalk.red(line));
+            else
+                lines.push(line);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+function hasWhitespace(path) {
+    return /\s/.test(path);
+}
+/**
+ * Approximates git's trailing hunk-context line. Scans backwards from the line before
+ * the hunk for the closest non-empty line that starts with an identifier-ish character
+ * (matches git's default xfuncname for plain text: `^[A-Za-z_$]`).
+ */
+function findHunkContext(oldLines, oldStart) {
+    const startIdx = oldStart - 2; // oldStart is 1-based line number of hunk's first line
+    for (let i = startIdx; i >= 0; i--) {
+        const line = oldLines[i];
+        if (line && /^[A-Z_a-z]/.test(line))
+            return line;
+    }
+    return undefined;
+}
+// Matches `git diff` hunk-range formatting:
+// - count === 1: omit `,1`
+// - count === 0: emit `<start-1>,0` (git convention — start is the line BEFORE the insertion point)
+// - otherwise: `<start>,<count>`
+function formatHunkRange(start, count) {
+    if (count === 0)
+        return `${start - 1},0`;
+    if (count === 1)
+        return `${start}`;
+    return `${start},${count}`;
+}