byterover-cli 3.8.3 → 3.9.0

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;

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

@@ -0,0 +1,16 @@
+export function parseMode(arg, staged) {
+    if (staged && arg !== undefined) {
+        throw new Error('--staged cannot be combined with a ref argument');
+    }
+    if (staged)
+        return { kind: 'staged' };
+    if (arg === undefined)
+        return { kind: 'unstaged' };
+    if (arg.includes('...')) {
+        throw new Error("three-dot syntax is not supported; use 'a..b' for two-dot range");
+    }
+    const rangeMatch = /^(.+?)\.\.(.+)$/.exec(arg);
+    if (rangeMatch)
+        return { from: rangeMatch[1], kind: 'range', to: rangeMatch[2] };
+    return { kind: 'ref-vs-worktree', ref: arg };
+}

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

@@ -6,6 +6,7 @@ import { formatTransportError } from '../../../../utils/error-messages.js';
 import { useExecuteVcRemote } from '../api/execute-vc-remote.js';
 const LABELS = {
     add: 'Adding remote...',
+    remove: 'Removing remote...',
     'set-url': 'Updating remote...',
     show: 'Fetching remote...',
 };
@@ -26,14 +27,28 @@ export function VcRemoteFlow({ onCancel, onComplete, subcommand, url }) {
                 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}.`);
+                switch (result.action) {
+                    case 'add': {
+                        onComplete(`Remote 'origin' set to ${result.url}.`);
+                        break;
+                    }
+                    case 'remove': {
+                        onComplete(`Remote 'origin' removed.`);
+                        break;
+                    }
+                    case 'set-url': {
+                        onComplete(`Remote 'origin' updated to ${result.url}.`);
+                        break;
+                    }
+                    case 'show': {
+                        onComplete(result.url ? `origin: ${result.url}` : 'No remote configured.');
+                        break;
+                    }
+                    default: {
+                        const exhaustive = result.action;
+                        onComplete(`Unknown action: ${String(exhaustive)}`);
+                        break;
+                    }
                 }
             },
         });