@myagentroam/node 0.1.3 → 0.1.6

package/dist/workspace.js

@@ -1,12 +1,13 @@
 import { createHash } from 'node:crypto';
 import { watch } from 'node:fs';
-import { lstat, readdir, readFile, realpath, stat, unlink } from 'node:fs/promises';
+import { lstat, mkdir, opendir, readdir, readFile, realpath, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { homedir, platform as hostPlatform } from 'node:os';
 import { dirname, isAbsolute, posix, relative, resolve, sep, win32 } from 'node:path';
 import { spawn } from 'node:child_process';
 import { minimatch } from 'minimatch';
 const GIT_TIMEOUT_MS = 5_000;
 const GIT_OUTPUT_LIMIT = 512 * 1024;
+const GIT_BINARY_PREVIEW_LIMIT = 4 * 1024 * 1024;
 const FILE_READ_LIMIT = 512 * 1024;
 const DIRECTORY_PAGE_LIMIT = 200;
 const DIRECTORY_PICKER_LIMIT = 200;
@@ -14,6 +15,7 @@ const SEARCH_RESULT_LIMIT = 200;
 const FILE_INDEX_IDLE_TTL_MS = 60 * 60 * 1_000;
 const FILE_INDEX_ENTRY_LIMIT = 100_000;
 const FILE_INDEX_FALLBACK_POLL_MS = 30_000;
+const FILE_INDEX_METADATA_CONCURRENCY = 32;
 const DEFAULT_QUICK_OPEN_EXCLUDES = [
     '**/.git/**',
     '**/node_modules/**',
@@ -27,6 +29,7 @@ const DEFAULT_QUICK_OPEN_EXCLUDES = [
     '**/build/**',
     '**/out/**',
     '**/coverage/**',
+    '**/test/runs/**',
     '**/.next/**',
     '**/.nuxt/**',
     '**/.svelte-kit/**',
@@ -41,6 +44,36 @@ const DEFAULT_QUICK_OPEN_EXCLUDES = [
     '**/venv/**'
 ];
 const REF_PATTERN = /^(?!-)(?!.*\.\.)(?!.*@\{)[A-Za-z0-9][A-Za-z0-9._/-]{0,254}$/;
+export async function createWorkspaceDirectory(parentPath, directoryName, allowedRoots) {
+    const name = directoryName.trim();
+    if (name.length === 0 ||
+        name.length > 255 ||
+        name === '.' ||
+        name === '..' ||
+        name.includes('/') ||
+        name.includes('\\') ||
+        name.includes('\0'))
+        throw new Error('WORKSPACE_DIRECTORY_NAME_INVALID');
+    const roots = await Promise.all(allowedRoots.map((root) => realpath(root)));
+    const parent = await realpath(parentPath).catch(() => {
+        throw new Error('WORKSPACE_DIRECTORY_NOT_ALLOWED');
+    });
+    const metadata = await stat(parent).catch(() => undefined);
+    if (metadata?.isDirectory() !== true || !isWithinAllowedRoot(parent, roots))
+        throw new Error('WORKSPACE_DIRECTORY_NOT_ALLOWED');
+    const target = resolve(parent, name);
+    if (dirname(target) !== parent || !isWithinAllowedRoot(target, roots))
+        throw new Error('WORKSPACE_DIRECTORY_NAME_INVALID');
+    try {
+        await mkdir(target);
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            throw new Error('WORKSPACE_DIRECTORY_EXISTS');
+        throw error;
+    }
+    return target;
+}
 /** A per-workspace, process-local index for the Quick Open file picker. */
 export class WorkspaceFileIndex {
     workspaceRoot;
@@ -63,6 +96,14 @@ export class WorkspaceFileIndex {
         await this.ensureLoaded();
         this.touch();
     }
+    async contentCandidates() {
+        await this.ensureLoaded();
+        this.touch();
+        return {
+            entries: this.entries.filter((entry) => entry.kind === 'FILE'),
+            truncated: this.truncated
+        };
+    }
     dispose() {
         if (this.expiryTimer !== undefined)
             clearTimeout(this.expiryTimer);
@@ -77,7 +118,7 @@ export class WorkspaceFileIndex {
         this.stale = true;
         this.signature = '';
     }
-    async search(query, cursor, limit = SEARCH_RESULT_LIMIT) {
+    async search(query, cursor, limit = SEARCH_RESULT_LIMIT, includeDirectories = false) {
         if (query.trim().length === 0 ||
             query.length > 256 ||
             !Number.isSafeInteger(limit) ||
@@ -87,15 +128,28 @@ export class WorkspaceFileIndex {
         await this.ensureLoaded();
         this.touch();
         const after = decodeSearchCursor(cursor, query);
-        const ranked = this.entries
-            .map((entry) => ({ entry, score: fuzzyPathScore(entry.path, query) }))
-            .filter((candidate) => candidate.score !== -1)
-            .sort((left, right) => right.score - left.score || left.entry.path.localeCompare(right.entry.path));
-        const start = after === undefined ? 0 : ranked.findIndex((candidate) => candidate.entry.path === after) + 1;
-        const page = ranked
-            .slice(Math.max(0, start), Math.max(0, start) + limit)
-            .map((candidate) => candidate.entry);
-        const next = ranked[Math.max(0, start) + limit]?.entry.path;
+        const afterEntry = after === undefined
+            ? undefined
+            : this.entries.find((entry) => entry.path === after && (includeDirectories || entry.kind === 'FILE'));
+        const afterScore = afterEntry === undefined ? -1 : fuzzyPathScore(afterEntry.path, query);
+        const afterCandidate = afterEntry === undefined || afterScore < 0
+            ? undefined
+            : { entry: afterEntry, score: afterScore };
+        const ranked = new RankedCandidateHeap(limit + 1);
+        for (const entry of this.entries) {
+            if (!includeDirectories && entry.kind !== 'FILE')
+                continue;
+            const score = fuzzyPathScore(entry.path, query);
+            if (score < 0)
+                continue;
+            const candidate = { entry, score };
+            if (afterCandidate !== undefined && compareRankedCandidate(candidate, afterCandidate) <= 0)
+                continue;
+            ranked.add(candidate);
+        }
+        const candidates = ranked.sorted();
+        const page = candidates.slice(0, limit).map((candidate) => candidate.entry);
+        const next = candidates[limit]?.entry.path;
         return {
             entries: page,
             nextCursor: next === undefined ? null : encodeSearchCursor(query, page.at(-1)?.path ?? after ?? ''),
@@ -125,43 +179,52 @@ export class WorkspaceFileIndex {
         const entryLimit = this.limits.entryLimit ?? FILE_INDEX_ENTRY_LIMIT;
         let truncated = false;
         const directories = ['.'];
-        while (directories.length > 0 && !truncated) {
-            const relativeDirectory = directories.shift();
-            const directory = await resolveWorkspaceEntry(root, relativeDirectory, true).catch(() => undefined);
+        let directoryCursor = 0;
+        while (directoryCursor < directories.length && !truncated) {
+            const relativeDirectory = directories[directoryCursor];
+            directoryCursor += 1;
+            const directory = await resolveWorkspaceEntryFromCanonicalRoot(root, relativeDirectory, true).catch(() => undefined);
             if (directory === undefined)
                 continue;
-            const children = await readdir(directory, { withFileTypes: true }).catch(() => undefined);
-            if (children === undefined)
+            const stream = await opendir(directory).catch(() => undefined);
+            if (stream === undefined)
                 continue;
-            for (const child of children) {
-                const candidatePath = relative(root, resolve(directory, child.name)).split(sep).join('/');
+            let pending = [];
+            const appendPending = async () => {
+                const resolvedEntries = await Promise.all(pending);
+                pending = [];
+                for (const entry of resolvedEntries) {
+                    if (entry === undefined)
+                        continue;
+                    if (entry.path === '.git' ||
+                        entry.path.startsWith('.git/') ||
+                        isExcluded(entry.path, excludes))
+                        continue;
+                    if (entry.kind === 'DIRECTORY')
+                        directories.push(entry.path);
+                    indexed.push(entry);
+                    if (indexed.length >= entryLimit) {
+                        truncated = true;
+                        break;
+                    }
+                }
+            };
+            for await (const child of stream) {
+                const candidatePath = relativeDirectory === '.'
+                    ? child.name
+                    : posix.join(relativeDirectory.replaceAll('\\', '/'), child.name);
                 if (candidatePath === '.git' ||
                     candidatePath.startsWith('.git/') ||
                     isExcluded(candidatePath, excludes))
                     continue;
-                const resolved = await resolveWorkspaceEntry(root, candidatePath, false).catch(() => undefined);
-                if (resolved === undefined)
-                    continue;
-                const metadata = await lstat(resolved).catch(() => undefined);
-                if (metadata === undefined || (!metadata.isFile() && !metadata.isDirectory()))
-                    continue;
-                const safePath = relative(root, resolved).split(sep).join('/');
-                if (metadata.isDirectory()) {
-                    directories.push(safePath);
-                    continue;
-                }
-                indexed.push({
-                    path: safePath,
-                    name: child.name,
-                    kind: 'FILE',
-                    size: metadata.size,
-                    modifiedAt: metadata.mtimeMs
-                });
-                if (indexed.length >= entryLimit) {
-                    truncated = true;
+                pending.push(inspectWorkspaceIndexEntry(root, candidatePath, child.name));
+                if (pending.length >= FILE_INDEX_METADATA_CONCURRENCY)
+                    await appendPending();
+                if (truncated)
                     break;
-                }
             }
+            if (!truncated && pending.length > 0)
+                await appendPending();
         }
         this.root = root;
         this.entries = indexed;
@@ -172,7 +235,12 @@ export class WorkspaceFileIndex {
         // fs.watch is advisory. Any change safely invalidates the in-memory index;
         // the next lookup rebuilds it and never trusts stale paths for file reads.
         try {
-            this.watcher = watch(root, { persistent: false, recursive: true }, () => {
+            this.watcher = watch(root, { persistent: false, recursive: true }, (_event, filename) => {
+                if (filename !== null) {
+                    const path = filename.toString().replaceAll('\\', '/');
+                    if (path === '.git' || path.startsWith('.git/') || isExcluded(path, excludes))
+                        return;
+                }
                 this.invalidate();
             });
             this.watcher.on('error', () => {
@@ -219,10 +287,11 @@ export class WorkspaceFileIndex {
     }
 }
 function fileIndexSignature(entries, truncated) {
-    return JSON.stringify({
-        truncated,
-        entries: entries.map((entry) => [entry.path, entry.size, entry.modifiedAt])
-    });
+    const hash = createHash('sha256');
+    hash.update(truncated ? '1\0' : '0\0');
+    for (const entry of entries)
+        hash.update(`${entry.path}\0${String(entry.size)}\0${String(entry.modifiedAt)}\0`);
+    return hash.digest('hex');
 }
 async function workspaceExcludePatterns(root) {
     const settingsPath = resolve(root, '.vscode/settings.json');
@@ -242,6 +311,64 @@ function isExcluded(path, patterns) {
     return patterns.some((pattern) => minimatch(path, pattern, { dot: true, nocase: hostPlatform() !== 'linux' }) ||
         minimatch(`${path}/`, pattern, { dot: true, nocase: hostPlatform() !== 'linux' }));
 }
+function compareRankedCandidate(left, right) {
+    return right.score - left.score || left.entry.path.localeCompare(right.entry.path);
+}
+/** Keeps only the best page-sized candidate set, with the current worst item at the root. */
+class RankedCandidateHeap {
+    capacity;
+    values = [];
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    add(candidate) {
+        if (this.values.length < this.capacity) {
+            this.values.push(candidate);
+            this.bubbleUp(this.values.length - 1);
+            return;
+        }
+        if (compareRankedCandidate(candidate, this.values[0]) >= 0)
+            return;
+        this.values[0] = candidate;
+        this.sinkDown(0);
+    }
+    sorted() {
+        return [...this.values].sort(compareRankedCandidate);
+    }
+    bubbleUp(start) {
+        let index = start;
+        while (index > 0) {
+            const parent = Math.floor((index - 1) / 2);
+            if (compareRankedCandidate(this.values[index], this.values[parent]) <= 0)
+                break;
+            [this.values[index], this.values[parent]] = [
+                this.values[parent],
+                this.values[index]
+            ];
+            index = parent;
+        }
+    }
+    sinkDown(start) {
+        let index = start;
+        while (true) {
+            const left = index * 2 + 1;
+            if (left >= this.values.length)
+                return;
+            const right = left + 1;
+            const worse = right < this.values.length &&
+                compareRankedCandidate(this.values[right], this.values[left]) > 0
+                ? right
+                : left;
+            if (compareRankedCandidate(this.values[worse], this.values[index]) <= 0)
+                return;
+            [this.values[index], this.values[worse]] = [
+                this.values[worse],
+                this.values[index]
+            ];
+            index = worse;
+        }
+    }
+}
 function fuzzyPathScore(path, query) {
     const source = path.toLocaleLowerCase();
     const needle = query.trim().toLocaleLowerCase();
@@ -352,6 +479,98 @@ export async function listWorkspaceFiles(workspaceRoot, requestedPath = '.', cur
         truncated: nextName !== undefined
     };
 }
+export async function mutateWorkspaceFile(workspaceRoot, mutation) {
+    const root = await realpath(workspaceRoot);
+    if (mutation.action === 'CREATE_FILE' || mutation.action === 'CREATE_DIRECTORY') {
+        const target = await resolveNewWorkspaceEntry(root, mutation.path);
+        if (mutation.action === 'CREATE_FILE')
+            await writeFile(target, '', { flag: 'wx' });
+        else
+            await mkdir(target);
+        return { path: workspaceRelativePath(root, target) };
+    }
+    await assertWorkspaceMutationPathHasNoSymlinks(root, mutation.path);
+    const source = await resolveWorkspaceEntryMetadata(root, mutation.path);
+    if (workspaceRelativePath(root, source.path) === '.')
+        throw new Error('FILE_ROOT_MUTATION_INVALID');
+    if (mutation.action === 'DELETE') {
+        await rm(source.path, { recursive: source.metadata.isDirectory(), force: false });
+        return { deleted: true };
+    }
+    const destination = await resolveNewWorkspaceEntry(root, mutation.destination);
+    if (source.metadata.isDirectory()) {
+        const destinationFromSource = relative(source.path, destination);
+        if (destinationFromSource === '' ||
+            (!isAbsolute(destinationFromSource) &&
+                destinationFromSource !== '..' &&
+                !destinationFromSource.startsWith(`..${sep}`)))
+            throw new Error('FILE_MOVE_DESCENDANT_INVALID');
+    }
+    await rename(source.path, destination);
+    return { path: workspaceRelativePath(root, destination) };
+}
+async function resolveNewWorkspaceEntry(root, requestedPath) {
+    const normalized = requestedPath.replaceAll('\\', '/');
+    const segments = normalized.split('/');
+    const name = segments.at(-1);
+    if (requestedPath.includes('\0') ||
+        normalized.startsWith('/') ||
+        isAbsolute(requestedPath) ||
+        win32.isAbsolute(normalized) ||
+        name === undefined ||
+        name.length === 0 ||
+        segments.some(invalidWorkspaceMutationSegment))
+        throw new Error('FILE_PATH_ESCAPE');
+    const parentPath = segments.length === 1 ? '.' : segments.slice(0, -1).join('/');
+    await assertWorkspaceMutationPathHasNoSymlinks(root, parentPath);
+    const parent = await resolveWorkspaceEntryFromCanonicalRoot(root, parentPath, true);
+    const target = resolve(parent, name);
+    try {
+        await lstat(target);
+        throw new Error('FILE_ALREADY_EXISTS');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    return target;
+}
+async function assertWorkspaceMutationPathHasNoSymlinks(root, requestedPath) {
+    const normalized = requestedPath.replaceAll('\\', '/');
+    if (normalized === '.')
+        return;
+    const segments = normalized.split('/');
+    if (requestedPath.includes('\0') ||
+        normalized.startsWith('/') ||
+        isAbsolute(requestedPath) ||
+        win32.isAbsolute(normalized) ||
+        segments.some(invalidWorkspaceMutationSegment))
+        throw new Error('FILE_PATH_ESCAPE');
+    let candidate = root;
+    for (const segment of segments) {
+        candidate = resolve(candidate, segment);
+        const metadata = await lstat(candidate).catch((error) => {
+            if (error.code === 'ENOENT')
+                throw new Error('FILE_NOT_FOUND');
+            throw error;
+        });
+        if (metadata.isSymbolicLink())
+            throw new Error('FILE_PATH_ESCAPE');
+    }
+}
+function invalidWorkspaceMutationSegment(segment) {
+    if (segment.length === 0 || segment === '.' || segment === '..' || segment === '.git')
+        return true;
+    if (hostPlatform() !== 'win32')
+        return false;
+    const normalized = segment.replace(/[. ]+$/u, '').toUpperCase();
+    return (/[<>:"|?*]/u.test(segment) ||
+        /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\..*)?$/u.test(normalized));
+}
+function workspaceRelativePath(root, path) {
+    const value = relative(root, path).split(sep).join('/');
+    return value.length === 0 ? '.' : value;
+}
 function isSkippableWorkspaceEntryError(error) {
     return (error instanceof Error &&
         (error.message === 'FILE_PATH_ESCAPE' ||
@@ -518,16 +737,28 @@ function isUtf8ContinuationByte(value) {
     return (value & 0b1100_0000) === 0b1000_0000;
 }
 /** Searches file names only, so an exploratory request cannot exfiltrate file contents. */
-export async function searchWorkspaceFiles(workspaceRoot, query, cursor, limit = SEARCH_RESULT_LIMIT) {
+export async function searchWorkspaceFiles(workspaceRoot, query, cursor, limit = SEARCH_RESULT_LIMIT, includeDirectories = false) {
     const index = new WorkspaceFileIndex(workspaceRoot);
     try {
-        return await index.search(query, cursor, limit);
+        return await index.search(query, cursor, limit, includeDirectories);
     }
     finally {
         index.dispose();
     }
 }
 async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory) {
+    const root = await realpath(workspaceRoot);
+    return resolveWorkspaceEntryFromCanonicalRoot(root, requestedPath, directory);
+}
+async function resolveWorkspaceEntryFromCanonicalRoot(root, requestedPath, directory) {
+    const entry = await resolveWorkspaceEntryMetadata(root, requestedPath);
+    if (directory
+        ? !entry.metadata.isDirectory()
+        : !entry.metadata.isFile() && !entry.metadata.isDirectory())
+        throw new Error(directory ? 'FILE_NOT_DIRECTORY' : 'FILE_NOT_REGULAR');
+    return entry.path;
+}
+async function resolveWorkspaceEntryMetadata(root, requestedPath) {
     if (requestedPath.includes('\0') ||
         requestedPath.length === 0 ||
         requestedPath.startsWith('/') ||
@@ -536,7 +767,6 @@ async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory) {
     const normalized = requestedPath.replaceAll('\\', '/');
     if (normalized.split('/').some((segment) => segment === '..' || segment === '.git'))
         throw new Error('FILE_PATH_ESCAPE');
-    const root = await realpath(workspaceRoot);
     let candidate;
     try {
         candidate = await realpath(resolve(root, normalized));
@@ -547,14 +777,39 @@ async function resolveWorkspaceEntry(workspaceRoot, requestedPath, directory) {
         throw error;
     }
     const pathToCandidate = relative(root, candidate);
-    if (pathToCandidate.startsWith('..') ||
+    if (isAbsolute(pathToCandidate) ||
+        pathToCandidate.startsWith('..') ||
         pathToCandidate === '..' ||
         pathToCandidate.startsWith(`..${sep}`))
         throw new Error('FILE_PATH_ESCAPE');
     const metadata = await lstat(candidate);
-    if (directory ? !metadata.isDirectory() : !metadata.isFile() && !metadata.isDirectory())
-        throw new Error(directory ? 'FILE_NOT_DIRECTORY' : 'FILE_NOT_REGULAR');
-    return candidate;
+    return { path: candidate, metadata };
+}
+async function inspectWorkspaceIndexEntry(root, requestedPath, name) {
+    try {
+        const entry = await resolveWorkspaceEntryMetadata(root, requestedPath);
+        if (!entry.metadata.isFile() && !entry.metadata.isDirectory())
+            return undefined;
+        const safePath = relative(root, entry.path).split(sep).join('/');
+        return entry.metadata.isDirectory()
+            ? {
+                path: safePath,
+                name,
+                kind: 'DIRECTORY',
+                size: null,
+                modifiedAt: entry.metadata.mtimeMs
+            }
+            : {
+                path: safePath,
+                name,
+                kind: 'FILE',
+                size: entry.metadata.size,
+                modifiedAt: entry.metadata.mtimeMs
+            };
+    }
+    catch {
+        return undefined;
+    }
 }
 function encodeDirectoryCursor(path, name) {
     return Buffer.from(JSON.stringify({ path, name })).toString('base64url');
@@ -776,6 +1031,201 @@ export async function resolveGitRepository(workspacePath, repositoryPath) {
     }
     return repository;
 }
+export async function listGitHistoryRefs(repository) {
+    const result = await runGit(repository, [
+        'for-each-ref',
+        '--format=%(refname)%09%(refname:short)%09%(objectname)%09%(HEAD)%09%(symref)',
+        'refs/heads',
+        'refs/remotes'
+    ]);
+    return result.text
+        .split(/\r?\n/)
+        .flatMap((line) => {
+        const [name, displayName, hash, head, symref] = line.split('\t');
+        if (name === undefined ||
+            displayName === undefined ||
+            hash === undefined ||
+            symref === undefined ||
+            symref.length > 0 ||
+            !/^[0-9a-f]{40,64}$/.test(hash))
+            return [];
+        const kind = name.startsWith('refs/heads/')
+            ? 'LOCAL'
+            : name.startsWith('refs/remotes/')
+                ? 'REMOTE'
+                : undefined;
+        return kind === undefined ? [] : [{ name, displayName, kind, hash, current: head === '*' }];
+    })
+        .sort((left, right) => left.kind.localeCompare(right.kind) || left.displayName.localeCompare(right.displayName));
+}
+function selectedHistoryRefs(available, requested) {
+    if (requested === undefined || requested.length === 0)
+        return available;
+    const unique = [...new Set(requested)];
+    const selected = unique.map((name) => available.find((entry) => entry.name === name));
+    if (selected.some((entry) => entry === undefined))
+        throw new Error('GIT_HISTORY_REF_INVALID');
+    return selected;
+}
+function historyCursor(offset, fingerprint) {
+    return Buffer.from(JSON.stringify({ offset, fingerprint })).toString('base64url');
+}
+function parseHistoryCursor(value, fingerprint) {
+    if (value === undefined)
+        return 0;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (!Number.isInteger(parsed.offset) ||
+            parsed.offset < 0 ||
+            parsed.fingerprint !== fingerprint)
+            throw new Error('invalid');
+        return parsed.offset;
+    }
+    catch {
+        throw new Error('GIT_HISTORY_CURSOR_INVALID');
+    }
+}
+export async function readGitHistory(repository, input) {
+    const available = await listGitHistoryRefs(repository);
+    const selected = selectedHistoryRefs(available, input.refs);
+    if (selected.length === 0)
+        return { commits: [], nextCursor: null };
+    const limit = input.limit ?? 50;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new Error('GIT_HISTORY_LIMIT_INVALID');
+    const names = selected.map((entry) => entry.name).sort();
+    // Bind the offset cursor to the exact branch tips. Advancing a branch invalidates
+    // the cursor instead of silently skipping or duplicating commits between pages.
+    const fingerprint = createHash('sha256')
+        .update(selected
+        .map((entry) => `${entry.name}\0${entry.hash}`)
+        .sort()
+        .join('\0'))
+        .digest('hex');
+    const offset = parseHistoryCursor(input.cursor, fingerprint);
+    const result = await runGit(repository, [
+        'log',
+        '--topo-order',
+        '--date-order',
+        `--skip=${offset}`,
+        `--max-count=${limit + 1}`,
+        '-z',
+        '--format=%H%x00%P%x00%an%x00%ae%x00%ct%x00%s',
+        ...names,
+        '--'
+    ]);
+    const refsByHash = new Map();
+    for (const entry of available) {
+        const refs = refsByHash.get(entry.hash) ?? [];
+        refs.push(entry.displayName);
+        refsByHash.set(entry.hash, refs);
+    }
+    const fields = result.text.split('\0');
+    const commits = [];
+    for (let index = 0; index + 5 < fields.length; index += 6) {
+        const [hash, parents = '', authorName = '', authorEmail = '', committedAt = '0', subject = ''] = fields.slice(index, index + 6);
+        if (hash === undefined || !/^[0-9a-f]{40,64}$/.test(hash))
+            continue;
+        commits.push({
+            hash,
+            parents: parents.length === 0 ? [] : parents.split(' '),
+            authorName,
+            authorEmail,
+            committedAt: Number(committedAt) * 1000,
+            subject,
+            refs: refsByHash.get(hash) ?? []
+        });
+    }
+    const hasMore = commits.length > limit;
+    return {
+        commits: commits.slice(0, limit),
+        nextCursor: hasMore ? historyCursor(offset + limit, fingerprint) : null
+    };
+}
+async function assertHistoryCommitReachable(repository, commit, refs) {
+    if (!/^[0-9a-f]{40,64}$/.test(commit))
+        throw new Error('GIT_HISTORY_COMMIT_INVALID');
+    const selected = selectedHistoryRefs(await listGitHistoryRefs(repository), refs);
+    for (const ref of selected) {
+        const result = await runGitAllowFailure(repository, [
+            'merge-base',
+            '--is-ancestor',
+            commit,
+            ref.name
+        ]);
+        if (result.code === 0)
+            return;
+    }
+    throw new Error('GIT_HISTORY_COMMIT_INVALID');
+}
+export async function readGitHistoryFiles(repository, commit, refs) {
+    await assertHistoryCommitReachable(repository, commit, refs);
+    const result = await runGit(repository, [
+        'diff-tree',
+        '--root',
+        '--first-parent',
+        '--no-commit-id',
+        '-r',
+        '-z',
+        '-M',
+        '-C',
+        '--name-status',
+        commit
+    ]);
+    const records = result.text.split('\0');
+    const files = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const status = records[index];
+        if (status === undefined || status.length === 0)
+            continue;
+        const code = status[0] ?? 'M';
+        if (code === 'R' || code === 'C') {
+            const previousPath = records[index + 1];
+            const path = records[index + 2];
+            if (previousPath !== undefined && path !== undefined)
+                files.push({ path, previousPath, change: gitChange(code) });
+            index += 2;
+        }
+        else {
+            const path = records[index + 1];
+            if (path !== undefined)
+                files.push({ path, change: gitChange(code) });
+            index += 1;
+        }
+    }
+    return files;
+}
+export async function readGitHistoryFileDiff(repository, commit, requestedPath, refs, requestedPreviousPath) {
+    await assertHistoryCommitReachable(repository, commit, refs);
+    const path = safeGitWorkspacePath(requestedPath);
+    const previousPath = requestedPreviousPath === undefined ? undefined : safeGitWorkspacePath(requestedPreviousPath);
+    const result = await runGit(repository, [
+        'show',
+        '--format=',
+        '--first-parent',
+        '--no-ext-diff',
+        '--no-textconv',
+        commit,
+        '--',
+        `:(literal)${path}`,
+        ...(previousPath === undefined || previousPath === path ? [] : [`:(literal)${previousPath}`])
+    ]);
+    const binary = result.output.includes(0) || result.text.includes('Binary files ');
+    if (binary) {
+        const [beforePreview, afterPreview] = await Promise.all([
+            readGitBinaryPreview(repository, `${commit}^`, previousPath ?? path),
+            readGitBinaryPreview(repository, commit, path)
+        ]);
+        return {
+            binary: true,
+            summary: `binary diff sha256=${createHash('sha256').update(result.output).digest('hex')} bytes=${result.output.length}`,
+            truncated: result.truncated,
+            ...(beforePreview === undefined ? {} : { beforePreview }),
+            ...(afterPreview === undefined ? {} : { afterPreview })
+        };
+    }
+    return { binary: false, text: result.text, truncated: result.truncated };
+}
 export async function readCurrentChanges(workspacePath) {
     return (await readCurrentChangesSummary(workspacePath)).changes;
 }
@@ -793,10 +1243,16 @@ export async function readCurrentChangeDiff(workspacePath, requestedPath) {
     const after = await readWorkingTreeText(workspacePath, path);
     const binary = result.output.includes(0) || result.text.includes('Binary files ') || after?.binary === true;
     if (binary) {
+        const [beforePreview, afterPreview] = await Promise.all([
+            readGitBinaryPreview(workspacePath, 'HEAD', path),
+            readWorkingTreeBinaryPreview(workspacePath, path)
+        ]);
         return {
             binary: true,
             summary: `binary diff sha256=${createHash('sha256').update(result.output).digest('hex')} bytes=${result.output.length}`,
-            truncated: result.truncated || after?.truncated === true
+            truncated: result.truncated || after?.truncated === true,
+            ...(beforePreview === undefined ? {} : { beforePreview }),
+            ...(afterPreview === undefined ? {} : { afterPreview })
         };
     }
     return {
@@ -834,6 +1290,32 @@ async function assertCurrentChangePathAccessible(workspacePath, path) {
         return;
     await resolveWorkspaceEntry(root, path, false);
 }
+async function readGitBinaryPreview(repository, ref, path) {
+    const result = await runGitAllowFailure(repository, ['show', `${ref}:${path}`], GIT_BINARY_PREVIEW_LIMIT);
+    if (result.code !== 0)
+        return undefined;
+    return result.truncated
+        ? { truncated: true }
+        : { contentBase64: result.output.toString('base64'), truncated: false };
+}
+async function readWorkingTreeBinaryPreview(workspacePath, path) {
+    const root = await realpath(workspacePath);
+    let file;
+    try {
+        file = await resolveWorkspaceEntry(root, path, false);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === 'FILE_NOT_FOUND')
+            return undefined;
+        throw error;
+    }
+    const metadata = await lstat(file);
+    if (!metadata.isFile())
+        return undefined;
+    if (metadata.size > GIT_BINARY_PREVIEW_LIMIT)
+        return { truncated: true };
+    return { contentBase64: (await readFile(file)).toString('base64'), truncated: false };
+}
 async function readWorkingTreeText(workspacePath, path) {
     const root = await realpath(workspacePath);
     let file;
@@ -938,7 +1420,7 @@ async function runGit(workspacePath, args) {
     }
     return result;
 }
-async function runGitAllowFailure(workspacePath, args) {
+async function runGitAllowFailure(workspacePath, args, outputLimit = GIT_OUTPUT_LIMIT) {
     return new Promise((resolve, reject) => {
         const child = spawn('git', [...args], {
             cwd: workspacePath,
@@ -952,12 +1434,13 @@ async function runGitAllowFailure(workspacePath, args) {
         let truncated = false;
         const timer = setTimeout(() => child.kill('SIGKILL'), GIT_TIMEOUT_MS);
         child.stdout.on('data', (chunk) => {
-            if (size < GIT_OUTPUT_LIMIT) {
-                const retained = chunk.subarray(0, Math.max(0, GIT_OUTPUT_LIMIT - size));
+            const remaining = Math.max(0, outputLimit - size);
+            if (remaining > 0) {
+                const retained = chunk.subarray(0, remaining);
                 chunks.push(retained);
                 size += retained.length;
             }
-            truncated ||= size >= GIT_OUTPUT_LIMIT;
+            truncated ||= chunk.length > remaining;
         });
         child.stderr.on('data', (chunk) => errors.push(chunk.subarray(0, 4096)));
         child.once('error', (error) => {
@@ -986,4 +1469,3 @@ function summarizeText(value) {
         bytes: Buffer.byteLength(value)
     });
 }
-//# sourceMappingURL=workspace.js.map