byterover-cli 3.8.2 → 3.9.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/webui/webui-middleware.js

@@ -1,6 +1,5 @@
 import express from 'express';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 /**
  * Creates an Express app that serves the web UI and config endpoint.
  *
@@ -20,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",
@@ -36,9 +40,11 @@ export function createWebUiMiddleware({ getConfig, webuiDistDir }) {
     // Serve static files from dist/webui/
     if (existsSync(webuiDistDir)) {
         app.use(express.static(webuiDistDir));
-        // SPA fallback: serve index.html for unmatched routes
+        // SPA fallback. `root` scopes send's dotfile check to the relative
+        // path; without it, a dotfile anywhere in the absolute install path
+        // (e.g. ~/.nvm/...) triggers a 404.
         app.get('*splat', (_req, res) => {
-            res.sendFile(join(webuiDistDir, 'index.html'));
+            res.sendFile('index.html', { root: webuiDistDir });
         });
     }
     return app;

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/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}`;
+}

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

@@ -0,0 +1,2 @@
+import type { VcDiffMode } from '../../../../../shared/transport/events/vc-events.js';
+export declare function parseMode(arg: string | undefined, staged: boolean): VcDiffMode;