byterover-cli 3.8.2 → 3.9.0

package/dist/server/infra/git/isomorphic-git-service.d.ts

@@ -1,4 +1,4 @@
-import type { AbortMergeGitParams, AddGitParams, AddRemoteGitParams, AheadBehind, BaseGitParams, BlobContents, CheckoutGitParams, CloneGitParams, CommitGitParams, CreateBranchGitParams, DeleteBranchGitParams, FetchGitParams, GetAheadBehindParams, GetBlobContentParams, GetBlobContentsParams, GetRemoteUrlGitParams, GetTrackingBranchParams, GitBranch, GitCommit, GitConflict, GitRemote, GitStatus, IGitService, InitGitParams, ListBranchesGitParams, LogGitParams, MergeGitParams, MergeResult, PullGitParams, PullResult, PushGitParams, PushResult, RemoveRemoteGitParams, ResetGitParams, ResetResult, SetTrackingBranchParams, TrackingBranch } from '../../core/interfaces/services/i-git-service.js';
+import type { AbortMergeGitParams, AddGitParams, AddRemoteGitParams, AheadBehind, BaseGitParams, BlobContents, ChangedFile, CheckoutGitParams, CloneGitParams, CommitGitParams, CreateBranchGitParams, DeleteBranchGitParams, FetchGitParams, GetAheadBehindParams, GetBlobContentParams, GetBlobContentsParams, GetRemoteUrlGitParams, GetTrackingBranchParams, GitBranch, GitCommit, GitConflict, GitRemote, GitStatus, IGitService, InitGitParams, ListBranchesGitParams, ListChangedFilesParams, LogGitParams, MergeGitParams, MergeResult, PullGitParams, PullResult, PushGitParams, PushResult, RemoveRemoteGitParams, ResetGitParams, ResetResult, SetTrackingBranchParams, TextBlob, TrackingBranch } from '../../core/interfaces/services/i-git-service.js';
 import type { IAuthStateStore } from '../../core/interfaces/state/i-auth-state-store.js';
 export declare class IsomorphicGitService implements IGitService {
     private readonly authStateStore;
@@ -21,7 +21,9 @@ export declare class IsomorphicGitService implements IGitService {
     getCurrentBranch(params: BaseGitParams): Promise<string | undefined>;
     getFilesWithConflictMarkers(params: BaseGitParams): Promise<string[]>;
     getRemoteUrl(params: GetRemoteUrlGitParams): Promise<string | undefined>;
+    getTextBlob(params: GetBlobContentParams): Promise<TextBlob | undefined>;
     getTrackingBranch(params: GetTrackingBranchParams): Promise<TrackingBranch | undefined>;
+    hashBlob(content: Buffer): Promise<string>;
     init(params: InitGitParams): Promise<void>;
     isAncestor(params: BaseGitParams & {
         ancestor: string;
@@ -30,6 +32,7 @@ export declare class IsomorphicGitService implements IGitService {
     isEmptyRepository(params: BaseGitParams): Promise<boolean>;
     isInitialized(params: BaseGitParams): Promise<boolean>;
     listBranches(params: ListBranchesGitParams): Promise<GitBranch[]>;
+    listChangedFiles(params: ListChangedFilesParams): Promise<ChangedFile[]>;
     listRemotes(params: BaseGitParams): Promise<GitRemote[]>;
     log(params: LogGitParams): Promise<GitCommit[]>;
     merge(params: MergeGitParams): Promise<MergeResult>;
@@ -40,7 +43,11 @@ export declare class IsomorphicGitService implements IGitService {
     setTrackingBranch(params: SetTrackingBranchParams): Promise<void>;
     status(params: BaseGitParams): Promise<GitStatus>;
     private buildBasicAuthHeaders;
+    private classifyRefVsWorkdir;
+    private classifyStagedRow;
+    private classifyUnstagedRow;
     private conflictsFromError;
+    private describeSide;
     private getAuthor;
     private getOnAuth;
     private getOnAuthFailure;
@@ -51,6 +58,10 @@ export declare class IsomorphicGitService implements IGitService {
      * to match native git behavior.
      */
     private guardStagedConflicts;
+    private hashWorkdirFile;
+    private isCommitishSide;
+    private listChangedBetweenCommits;
+    private listChangedFromMatrix;
     /**
      * Manual merge for unrelated histories (no common ancestor).
      * isomorphic-git throws MergeNotSupportedError because it can't handle
@@ -59,6 +70,12 @@ export declare class IsomorphicGitService implements IGitService {
     private mergeUnrelatedHistories;
     private parseMatrix;
     private readBlobOid;
+    /**
+     * Reads the raw blob bytes + full oid at the given ref in a single pass.
+     * Returns `undefined` when the blob is absent (path missing, ref unresolved, etc.).
+     * Used by {@link getTextBlob}; callers downstream decide binary vs text.
+     */
+    private readRawBlob;
     private requireDirectory;
     private requireToken;
     /**
@@ -71,6 +88,12 @@ export declare class IsomorphicGitService implements IGitService {
      * Falls back to git.resolveRef for plain refs.
      */
     private resolveRefExpression;
+    /**
+     * Resolve a single ref (branch name, tag, full SHA, or short SHA).
+     * Falls back to `git.expandOid` for short SHAs since `git.resolveRef`
+     * only accepts full OIDs and symbolic refs.
+     */
+    private resolveSingleRef;
     /**
      * Fixes conflict markers written by isomorphic-git to match native git:
      * 1. Replaces `<<<<<<< <branchName>` with `<<<<<<< HEAD`

package/dist/server/infra/git/isomorphic-git-service.js

@@ -246,13 +246,13 @@ export class IsomorphicGitService {
         const result = Object.fromEntries(paths.map((p) => [p, undefined]));
         if (paths.length === 0)
             return result;
-        if (ref === 'HEAD') {
-            const headOid = await git.resolveRef({ dir, fs, ref: 'HEAD' }).catch(() => null);
-            if (!headOid)
+        if (ref !== 'STAGE') {
+            const commitOid = await this.resolveRefExpression(dir, ref.commitish).catch(() => null);
+            if (!commitOid)
                 return result;
             await Promise.all(paths.map(async (path) => {
                 try {
-                    const { blob } = await git.readBlob({ dir, filepath: path, fs, oid: headOid });
+                    const { blob } = await git.readBlob({ dir, filepath: path, fs, oid: commitOid });
                     result[path] = Buffer.from(blob).toString('utf8');
                 }
                 catch {
@@ -361,6 +361,16 @@ export class IsomorphicGitService {
         const result = await git.getConfig({ dir, fs, path: `remote.${params.remote}.url` });
         return result === undefined || result === null ? undefined : String(result);
     }
+    async getTextBlob(params) {
+        const dir = this.requireDirectory(params);
+        const { path, ref } = params;
+        const raw = await this.readRawBlob(dir, path, ref);
+        if (!raw)
+            return undefined;
+        if (raw.bytes.includes(0))
+            return { binary: true, content: '', oid: raw.oid.slice(0, 7) };
+        return { content: Buffer.from(raw.bytes).toString('utf8'), oid: raw.oid.slice(0, 7) };
+    }
     async getTrackingBranch(params) {
         const dir = this.requireDirectory(params);
         const remote = await git.getConfig({ dir, fs, path: `branch.${params.branch}.remote` });
@@ -374,6 +384,10 @@ export class IsomorphicGitService {
         const remoteBranch = mergeStr.startsWith('refs/heads/') ? mergeStr.slice('refs/heads/'.length) : mergeStr;
         return { remote: String(remote), remoteBranch };
     }
+    async hashBlob(content) {
+        const { oid } = await git.hashBlob({ object: content });
+        return oid.slice(0, 7);
+    }
     async init(params) {
         const dir = this.requireDirectory(params);
         await git.init({ defaultBranch: params.defaultBranch ?? 'main', dir, fs });
@@ -431,6 +445,15 @@ export class IsomorphicGitService {
         }
         return result;
     }
+    async listChangedFiles(params) {
+        const dir = this.requireDirectory(params);
+        const { from, to } = params;
+        // Commit-vs-commit: walk both trees, compare oids
+        if (from !== 'STAGE' && from !== 'WORKDIR' && to !== 'STAGE' && to !== 'WORKDIR') {
+            return this.listChangedBetweenCommits(dir, from.commitish, to.commitish);
+        }
+        return this.listChangedFromMatrix(dir, from, to);
+    }
     async listRemotes(params) {
         const dir = this.requireDirectory(params);
         const remotes = await git.listRemotes({ dir, fs });
@@ -737,6 +760,56 @@ export class IsomorphicGitService {
         const credentials = Buffer.from(`${userId}:${sessionKey}`).toString('base64');
         return { Authorization: `Basic ${credentials}` };
     }
+    async classifyRefVsWorkdir(dir, fromOid, refSet, matrix) {
+        // "Tracked in workdir" = present on disk (workdir != 0) AND tracked (HEAD or stage has it).
+        // This excludes untracked files (matches `git diff <commit>` which does not show untracked).
+        const trackedOnDisk = new Set();
+        for (const [filepath, head, workdir, stage] of matrix) {
+            if (workdir !== 0 && (head !== 0 || stage !== 0))
+                trackedOnDisk.add(String(filepath));
+        }
+        const candidates = new Set([...refSet, ...trackedOnDisk]);
+        const results = await Promise.all([...candidates].map(async (path) => {
+            const inRef = refSet.has(path);
+            const inWork = trackedOnDisk.has(path);
+            if (inRef && !inWork)
+                return { path, status: 'deleted' };
+            if (!inRef && inWork)
+                return { path, status: 'added' };
+            if (inRef && inWork) {
+                const [fromBlobOid, workOid] = await Promise.all([
+                    this.readBlobOid(dir, fromOid, path),
+                    this.hashWorkdirFile(dir, path),
+                ]);
+                if (fromBlobOid && workOid && fromBlobOid !== workOid)
+                    return { path, status: 'modified' };
+            }
+            return undefined;
+        }));
+        return results.filter((r) => r !== undefined).sort((a, b) => a.path.localeCompare(b.path));
+    }
+    classifyStagedRow(row) {
+        const [filepath, head, , stage] = row;
+        const path = String(filepath);
+        if (head === 0 && (stage === 2 || stage === 3))
+            return { path, status: 'added' };
+        if (head === 1 && stage === 0)
+            return { path, status: 'deleted' };
+        if (head === 1 && (stage === 2 || stage === 3))
+            return { path, status: 'modified' };
+        return undefined;
+    }
+    classifyUnstagedRow(row) {
+        const [filepath, head, workdir, stage] = row;
+        const path = String(filepath);
+        if (head === 0 && stage === 0)
+            return undefined; // skip untracked
+        if (workdir === 0 && (stage === 1 || stage === 2 || stage === 3))
+            return { path, status: 'deleted' };
+        if (workdir === 2 && (stage === 1 || stage === 3))
+            return { path, status: 'modified' };
+        return undefined;
+    }
     conflictsFromError(error) {
         if (!IsomorphicGitService.isConflictError(error))
             return [];
@@ -756,6 +829,13 @@ export class IsomorphicGitService {
         }))
             .sort((a, b) => a.path.localeCompare(b.path));
     }
+    describeSide(side) {
+        if (side === 'STAGE')
+            return 'STAGE';
+        if (side === 'WORKDIR')
+            return 'WORKDIR';
+        return `commitish(${side.commitish})`;
+    }
     getAuthor() {
         const token = this.authStateStore.getToken();
         if (!token)
@@ -812,6 +892,69 @@ export class IsomorphicGitService {
                 '\nPlease commit your changes or stash them before you switch branches.');
         }
     }
+    async hashWorkdirFile(dir, path) {
+        try {
+            const buf = await fs.promises.readFile(join(dir, path));
+            const { oid } = await git.hashBlob({ object: buf });
+            return oid;
+        }
+        catch {
+            return null;
+        }
+    }
+    isCommitishSide(side) {
+        return side !== 'STAGE' && side !== 'WORKDIR';
+    }
+    async listChangedBetweenCommits(dir, fromRef, toRef) {
+        const [fromOid, toOid] = await Promise.all([
+            this.resolveRefExpression(dir, fromRef),
+            this.resolveRefExpression(dir, toRef),
+        ]);
+        const changes = [];
+        await git.walk({
+            dir,
+            fs,
+            async map(filepath, [a, b]) {
+                if (filepath === '.')
+                    return;
+                const [aType, bType] = await Promise.all([a?.type(), b?.type()]);
+                if (aType === 'tree' || bType === 'tree')
+                    return;
+                if (!a && b && bType === 'blob') {
+                    changes.push({ path: filepath, status: 'added' });
+                    return;
+                }
+                if (a && !b && aType === 'blob') {
+                    changes.push({ path: filepath, status: 'deleted' });
+                    return;
+                }
+                if (a && b && aType === 'blob' && bType === 'blob') {
+                    const [aOid, bOid] = await Promise.all([a.oid(), b.oid()]);
+                    if (aOid !== bOid)
+                        changes.push({ path: filepath, status: 'modified' });
+                }
+            },
+            // eslint-disable-next-line new-cap
+            trees: [git.TREE({ ref: fromOid }), git.TREE({ ref: toOid })],
+        });
+        return changes;
+    }
+    async listChangedFromMatrix(dir, from, to) {
+        const matrix = await git.statusMatrix({ dir, fs });
+        if (from === 'STAGE' && to === 'WORKDIR') {
+            return matrix.map((row) => this.classifyUnstagedRow(row)).filter((c) => c !== undefined);
+        }
+        if (this.isCommitishSide(from) && to === 'STAGE') {
+            return matrix.map((row) => this.classifyStagedRow(row)).filter((c) => c !== undefined);
+        }
+        if (this.isCommitishSide(from) && to === 'WORKDIR') {
+            const fromOid = await this.resolveRefExpression(dir, from.commitish);
+            const tracked = await git.listFiles({ dir, fs, ref: fromOid });
+            const trackedSet = new Set(tracked);
+            return this.classifyRefVsWorkdir(dir, fromOid, trackedSet, matrix);
+        }
+        throw new GitError(`unsupported diff side combination: from=${this.describeSide(from)} to=${this.describeSide(to)}`);
+    }
     /**
      * Manual merge for unrelated histories (no common ancestor).
      * isomorphic-git throws MergeNotSupportedError because it can't handle
@@ -940,6 +1083,46 @@ export class IsomorphicGitService {
             return null;
         }
     }
+    /**
+     * Reads the raw blob bytes + full oid at the given ref in a single pass.
+     * Returns `undefined` when the blob is absent (path missing, ref unresolved, etc.).
+     * Used by {@link getTextBlob}; callers downstream decide binary vs text.
+     */
+    async readRawBlob(dir, path, ref) {
+        if (ref === 'STAGE') {
+            let found;
+            await git
+                .walk({
+                dir,
+                fs,
+                async map(filepath, [entry]) {
+                    if (filepath !== path || !entry)
+                        return;
+                    if ((await entry.type()) !== 'blob')
+                        return;
+                    const oid = await entry.oid();
+                    const { blob } = await git.readBlob({ dir, fs, oid });
+                    found = { bytes: blob, oid };
+                },
+                // eslint-disable-next-line new-cap
+                trees: [git.STAGE()],
+            })
+                .catch(() => {
+                // leave found undefined
+            });
+            return found;
+        }
+        const commitOid = await this.resolveRefExpression(dir, ref.commitish).catch(() => null);
+        if (!commitOid)
+            return undefined;
+        try {
+            const { blob, oid } = await git.readBlob({ dir, filepath: path, fs, oid: commitOid });
+            return { bytes: blob, oid };
+        }
+        catch {
+            return undefined;
+        }
+    }
     requireDirectory(params) {
         // Guard against empty string — undefined/null are caught by TypeScript at compile time
         if (!params.directory)
@@ -1006,14 +1189,14 @@ export class IsomorphicGitService {
     async resolveRefExpression(dir, ref) {
         const tildeMatch = /^(.+)~(\d+)$/.exec(ref);
         if (!tildeMatch) {
-            return git.resolveRef({ dir, fs, ref });
+            return this.resolveSingleRef(dir, ref);
         }
         const baseRef = tildeMatch[1];
         const count = Number.parseInt(tildeMatch[2], 10);
         if (count === 0) {
-            return git.resolveRef({ dir, fs, ref: baseRef });
+            return this.resolveSingleRef(dir, baseRef);
         }
-        let oid = await git.resolveRef({ dir, fs, ref: baseRef });
+        let oid = await this.resolveSingleRef(dir, baseRef);
         for (let i = 0; i < count; i++) {
             // eslint-disable-next-line no-await-in-loop
             const commit = await git.readCommit({ dir, fs, oid });
@@ -1024,6 +1207,23 @@ export class IsomorphicGitService {
         }
         return oid;
     }
+    /**
+     * Resolve a single ref (branch name, tag, full SHA, or short SHA).
+     * Falls back to `git.expandOid` for short SHAs since `git.resolveRef`
+     * only accepts full OIDs and symbolic refs.
+     */
+    async resolveSingleRef(dir, ref) {
+        try {
+            return await git.resolveRef({ dir, fs, ref });
+        }
+        catch (error) {
+            // Short SHA: 4-39 hex chars. Try expandOid which disambiguates against the object DB.
+            if (/^[\da-f]{4,39}$/i.test(ref)) {
+                return git.expandOid({ dir, fs, oid: ref });
+            }
+            throw error;
+        }
+    }
     /**
      * Fixes conflict markers written by isomorphic-git to match native git:
      * 1. Replaces `<<<<<<< <branchName>` with `<<<<<<< HEAD`

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

@@ -13,6 +13,7 @@ export class ConfigHandler {
         this.transport.onRequest(ConfigEvents.GET_ENVIRONMENT, () => {
             const config = getCurrentConfig();
             return {
+                gitRemoteBaseUrl: config.gitRemoteBaseUrl,
                 iamBaseUrl: config.iamBaseUrl,
                 isDevelopment: isDevelopment(),
                 webAppUrl: config.webAppUrl,

package/dist/server/infra/transport/handlers/locations-handler.d.ts

@@ -24,4 +24,5 @@ export declare class LocationsHandler {
     constructor(deps: LocationsHandlerDeps);
     setup(): void;
     private buildLocations;
+    private handleReveal;
 }

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

@@ -1,6 +1,8 @@
+import { spawn } from 'node:child_process';
 import { join } from 'node:path';
-import { LocationsEvents } from '../../../../shared/transport/events/locations-events.js';
+import { LocationsEvents, } from '../../../../shared/transport/events/locations-events.js';
 import { BRV_DIR, CONTEXT_TREE_DIR } from '../../../constants.js';
+import { resolveRevealCommand } from './reveal-command.js';
 /**
  * Handles locations:get event.
  * Returns all registered project locations with context tree status.
@@ -31,6 +33,7 @@ export class LocationsHandler {
                 return { locations: [] };
             }
         });
+        this.transport.onRequest(LocationsEvents.REVEAL, async (data) => this.handleReveal(data));
     }
     async buildLocations(currentProjectPath) {
         const all = this.projectRegistry.getAll();
@@ -75,4 +78,25 @@ export class LocationsHandler {
             return (all.get(b.projectPath)?.registeredAt ?? 0) - (all.get(a.projectPath)?.registeredAt ?? 0);
         });
     }
+    async handleReveal(data) {
+        const { projectPath } = data;
+        if (!projectPath)
+            throw new Error('projectPath is required');
+        // Only allow revealing paths that are registered projects — the client
+        // controls this argument, so we must not trust it blindly.
+        const registered = this.projectRegistry.getAll();
+        if (!registered.has(projectPath)) {
+            throw new Error('Project is not registered.');
+        }
+        const exists = await this.pathExists(projectPath).catch(() => false);
+        if (!exists)
+            throw new Error('Project folder no longer exists.');
+        const { args, command } = resolveRevealCommand(process.platform, projectPath);
+        const child = spawn(command, args, { detached: true, stdio: 'ignore', windowsHide: true });
+        child.on('error', () => {
+            /* best-effort — nothing to report back once the ack resolved */
+        });
+        child.unref();
+        return { projectPath };
+    }
 }

package/dist/server/infra/transport/handlers/reveal-command.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves the OS-native command for revealing a path in the system file manager.
+ * Extracted so the branching can be unit-tested without spawning real processes.
+ */
+export type RevealCommand = {
+    args: string[];
+    command: string;
+};
+export declare function resolveRevealCommand(platformName: NodeJS.Platform, targetPath: string): RevealCommand;

package/dist/server/infra/transport/handlers/reveal-command.js

@@ -0,0 +1,7 @@
+export function resolveRevealCommand(platformName, targetPath) {
+    if (platformName === 'darwin')
+        return { args: [targetPath], command: 'open' };
+    if (platformName === 'win32')
+        return { args: [targetPath], command: 'explorer' };
+    return { args: [targetPath], command: 'xdg-open' };
+}

package/dist/server/infra/transport/handlers/vc-handler.d.ts

@@ -40,6 +40,11 @@ export declare class VcHandler {
     constructor(deps: IVcHandlerDeps);
     setup(): void;
     private buildAuthorHint;
+    /**
+     * 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).
+     */
+    private buildDiffFile;
     private buildNoRemoteMessage;
     private computeDiff;
     /**
@@ -77,6 +82,12 @@ export declare class VcHandler {
     private handleRemote;
     private handleReset;
     private handleStatus;
+    /**
+     * 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`.
+     */
+    private readSideEntry;
     /**
      * Resolve clone request data into a clean cogit URL + team/space info.
      * Accepts either a URL or explicit teamName/spaceName.