@orion-agents/orion-code 0.3.14 → 0.3.17

package/dist/web/git-compare-service.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitCompareReader = createGitCompareReader;
+/**
+ * v0.3.17 S5 — branch and version comparison (plan G5).
+ *
+ * Two modes, and the difference between them is the whole point:
+ *   - `snapshot`: the tree difference between A and B;
+ *   - `merge-base`: what B introduced since the branches diverged.
+ *
+ * Semantics this module is responsible for:
+ *   - refs are resolved to **commits** before anything else, and the resolved OIDs are part of
+ *     the result, so the UI can detect that a ref moved and freeze the opened result instead
+ *     of silently comparing against a different tree (plan G5);
+ *   - `merge-base --all` with more than one answer is refused — picking one candidate would
+ *     present an arbitrary choice as if it were the unique divergence point, so the caller is
+ *     told to use the two-endpoint mode instead (plan G5);
+ *   - no common ancestor and a shallow clone with missing objects produce distinct, explicit
+ *     errors rather than an empty file list that looks like a legitimate answer;
+ *   - a ref name is validated before it ever reaches argv: revision expressions, ranges and
+ *     pathspec magic are refused.
+ */
+const redaction_1 = require("../services/redaction");
+const errors_1 = require("./errors");
+const REF_NAME_PATTERN = /^[0-9A-Za-z](?:[0-9A-Za-z._/-]{0,250}[0-9A-Za-z])?$/u;
+const COMPARE_FILE_LIMIT = 2000;
+/** Resolves a ref-ish name to a commit, refusing anything that is not a plain ref name. */
+function assertRefName(value, name) {
+    if (typeof value !== 'string' || !REF_NAME_PATTERN.test(value) || value.includes('..')) {
+        throw new errors_1.WebWorkbenchError(400, `${name} must be a branch, tag or commit hash.`, 'git_ref_invalid');
+    }
+    return value;
+}
+async function resolveCommit(runGit, ref) {
+    const resolved = (await runGit(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]).catch(() => ''))
+        .toString()
+        .trim();
+    if (!/^[0-9a-f]{7,64}$/iu.test(resolved)) {
+        throw new errors_1.WebWorkbenchError(404, `The ref ${ref} could not be resolved to a commit.`, 'git_ref_not_found');
+    }
+    return resolved;
+}
+function createGitCompareReader(options) {
+    const { runGit } = options;
+    const numstat = async (base, head) => {
+        const raw = await runGit([
+            'diff',
+            '--numstat',
+            '-z',
+            '--no-ext-diff',
+            '--no-textconv',
+            base,
+            head,
+        ]);
+        const files = [];
+        const fields = raw.split('\0');
+        let index = 0;
+        while (index < fields.length) {
+            const record = fields[index];
+            index += 1;
+            if (!record)
+                continue;
+            const [added, deleted, inlinePath] = record.split('\t');
+            let path = inlinePath ?? '';
+            let renamedFrom = null;
+            if (path === '' && index + 1 < fields.length) {
+                renamedFrom = fields[index];
+                path = fields[index + 1];
+                index += 2;
+            }
+            if (!path)
+                continue;
+            const binary = added === '-' || deleted === '-';
+            files.push(Object.freeze({
+                path,
+                renamedFrom: renamedFrom || null,
+                additions: binary ? 0 : Number(added) || 0,
+                deletions: binary ? 0 : Number(deleted) || 0,
+                binary,
+                sensitive: (0, redaction_1.isSensitiveFilePath)(path),
+            }));
+            if (files.length >= COMPARE_FILE_LIMIT)
+                break;
+        }
+        return Object.freeze({
+            files,
+            additions: files.reduce((sum, file) => sum + file.additions, 0),
+            deletions: files.reduce((sum, file) => sum + file.deletions, 0),
+            truncated: files.length >= COMPARE_FILE_LIMIT,
+        });
+    };
+    return {
+        /** Validates a pair of refs and returns their commits, without computing anything yet. */
+        async resolvePair(baseRef, headRef) {
+            const base = assertRefName(baseRef, 'base');
+            const head = assertRefName(headRef, 'head');
+            const [baseOid, headOid] = await Promise.all([
+                resolveCommit(runGit, base),
+                resolveCommit(runGit, head),
+            ]);
+            return Object.freeze({
+                baseRef: base,
+                headRef: head,
+                baseOid,
+                headOid,
+                baseLabel: base,
+                headLabel: head,
+            });
+        },
+        async compare(input) {
+            const pair = await this.resolvePair(input.baseRef, input.headRef);
+            const mode = input.mode === 'merge-base' ? 'merge-base' : 'snapshot';
+            let baseOid = pair.baseOid;
+            let mergeBaseOid = null;
+            if (mode === 'merge-base') {
+                // `--all` is the honest way to ask: a single answer means one divergence point, and
+                // more than one means the question has no unique answer.
+                const raw = await runGit(['merge-base', '--all', pair.baseOid, pair.headOid]).catch(error => {
+                    const message = error instanceof Error ? error.message : '';
+                    if (/missing|bad object/iu.test(message)) {
+                        throw new errors_1.WebWorkbenchError(409, 'The repository does not contain the objects needed for this comparison (a shallow clone?).', 'git_shallow_history');
+                    }
+                    // git exits non-zero with no candidates when the histories are unrelated, and with
+                    // a diagnostic when objects are missing — those are different failures.
+                    throw new errors_1.WebWorkbenchError(409, 'The two refs have no common ancestor; use the two-endpoint comparison instead.', 'git_merge_base_missing');
+                });
+                const candidates = raw
+                    .split('\n')
+                    .map(line => line.trim())
+                    .filter(line => /^[0-9a-f]{7,64}$/iu.test(line));
+                if (candidates.length === 0) {
+                    throw new errors_1.WebWorkbenchError(409, 'The two refs have no common ancestor; use the two-endpoint comparison instead.', 'git_merge_base_missing');
+                }
+                if (candidates.length > 1) {
+                    throw new errors_1.WebWorkbenchError(409, `These refs have ${candidates.length} merge bases, so there is no unique divergence point. Use the two-endpoint comparison instead.`, 'git_merge_base_multiple');
+                }
+                mergeBaseOid = candidates[0];
+                baseOid = mergeBaseOid;
+            }
+            const stats = await numstat(baseOid, pair.headOid);
+            return Object.freeze({
+                mode,
+                requestedBaseRef: pair.baseRef,
+                requestedHeadRef: pair.headRef,
+                baseOid,
+                headOid: pair.headOid,
+                baseLabel: mode === 'merge-base' && mergeBaseOid !== null
+                    ? `共同祖先 ${mergeBaseOid.slice(0, 10)}`
+                    : pair.baseLabel,
+                headLabel: pair.headLabel,
+                mergeBaseOid,
+                files: stats.files,
+                additions: stats.additions,
+                deletions: stats.deletions,
+                truncated: stats.truncated,
+            });
+        },
+    };
+}
+//# sourceMappingURL=git-compare-service.js.map

package/dist/web/git-diff-document.d.ts

@@ -0,0 +1,83 @@
+/**
+ * v0.3.17 S2 — structured Git diff document.
+ *
+ * The v1 diff page exposed raw unified-diff text lines and a `## Staged` style section
+ * banner. That shape made line numbers, side-by-side rendering, hunk folding and the
+ * "jump to next change" navigation impossible without re-parsing text in the browser.
+ *
+ * This module parses the raw lines the Host already produces into a hunk/line model with
+ * real old/new line numbers, a stable line id, per-hunk completeness, and the write
+ * capabilities that apply to the selected comparison source.
+ *
+ * Deliberate limits for S2:
+ *   - No hunk or line level writes. `capabilities.stageHunk` / `stageLines` are always
+ *     false and carry a reason; staging granularity is S3 (plan §10).
+ *   - Word level highlighting and ignore-whitespace views are S5. This model preserves the
+ *     original text so those can be computed later without a protocol change.
+ */
+import type { WebGitFileSourceV1 } from './git-file-source';
+export type GitDiffLineKindV2 = 'context' | 'addition' | 'deletion' | 'meta';
+export interface GitDiffLineV2 {
+    /** Stable inside one document: `<hunkId>#<index>`. */
+    readonly lineId: string;
+    readonly kind: GitDiffLineKindV2;
+    readonly oldLineNumber: number | null;
+    readonly newLineNumber: number | null;
+    /** Content without the leading `+`/`-`/space marker. */
+    readonly text: string;
+    /** The original line including its marker, so copy never loses fidelity. */
+    readonly raw: string;
+}
+export interface GitHunkV2 {
+    readonly hunkId: string;
+    readonly header: string;
+    readonly oldStart: number;
+    readonly oldLines: number;
+    readonly newStart: number;
+    readonly newLines: number;
+    readonly contextLabel: string;
+    readonly lines: readonly GitDiffLineV2[];
+    /** False when pagination cut this hunk; partial hunks must not be written (plan G3). */
+    readonly complete: boolean;
+}
+export type GitDiffDocumentKindV2 = 'text' | 'binary' | 'symlink' | 'submodule' | 'metadata';
+export interface GitDiffCapabilitiesV2 {
+    readonly stageFile: boolean;
+    readonly unstageFile: boolean;
+    readonly stageHunk: boolean;
+    readonly unstageHunk: boolean;
+    readonly stageLines: boolean;
+    readonly reason?: string;
+}
+export interface GitDiffDocumentV2 {
+    readonly schemaVersion: 2;
+    readonly fileToken: string;
+    readonly path: string;
+    readonly source: WebGitFileSourceV1;
+    /** Set only for a historical comparison: the base tree and how it was chosen. */
+    readonly baseOid?: string;
+    readonly baseLabel?: string;
+    readonly repositoryRevision: string;
+    readonly kind: GitDiffDocumentKindV2;
+    readonly binary: boolean;
+    readonly hunks: readonly GitHunkV2[];
+    /** Metadata lines that are not part of any hunk (file headers, mode changes, …). */
+    readonly meta: readonly string[];
+    readonly completeness: 'complete' | 'paged' | 'limited';
+    readonly additions: number;
+    readonly deletions: number;
+    readonly lineCount: number;
+    readonly nextCursor: string | null;
+    readonly capabilities: GitDiffCapabilitiesV2;
+}
+export declare function parseGitDiffDocument(input: {
+    readonly fileToken: string;
+    readonly path: string;
+    readonly source: WebGitFileSourceV1;
+    readonly repositoryRevision: string;
+    readonly lines: readonly string[];
+    readonly hasMore: boolean;
+    /** Host-signed continuation cursor, or null. Never synthesised here. */
+    readonly nextCursor: string | null;
+}): GitDiffDocumentV2;
+//# sourceMappingURL=git-diff-document.d.ts.map

package/dist/web/git-diff-document.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGitDiffDocument = parseGitDiffDocument;
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/u;
+const NO_NEWLINE = '\';
+/** Document level header lines Git emits before the first hunk. */
+function isMetaLine(line) {
+    return (line.startsWith('## ') ||
+        line.startsWith('diff --git ') ||
+        line.startsWith('index ') ||
+        line.startsWith('--- ') ||
+        line.startsWith('+++ ') ||
+        line.startsWith('new file mode ') ||
+        line.startsWith('deleted file mode ') ||
+        line.startsWith('old mode ') ||
+        line.startsWith('new mode ') ||
+        line.startsWith('similarity index ') ||
+        line.startsWith('dissimilarity index ') ||
+        line.startsWith('rename from ') ||
+        line.startsWith('rename to ') ||
+        line.startsWith('copy from ') ||
+        line.startsWith('copy to ') ||
+        line.startsWith('Binary files ') ||
+        line.startsWith('GIT binary patch') ||
+        line.startsWith('Submodule '));
+}
+function detectKind(lines) {
+    if (lines.some(line => line.startsWith('Binary files ') || line.startsWith('GIT binary patch'))) {
+        return 'binary';
+    }
+    if (lines.some(line => line.startsWith('Submodule ')))
+        return 'submodule';
+    if (lines.some(line => line.startsWith('old mode ') || line.startsWith('new mode '))) {
+        return 'metadata';
+    }
+    return 'text';
+}
+/** Write capabilities implied by the comparison source. */
+function capabilitiesFor(source) {
+    const hunkWritesUnavailable = 'Hunk 与选中行级写入将在 S3 提供。';
+    if (source === 'staged') {
+        return Object.freeze({
+            stageFile: false,
+            unstageFile: true,
+            stageHunk: false,
+            unstageHunk: false,
+            stageLines: false,
+            reason: hunkWritesUnavailable,
+        });
+    }
+    if (source === 'unstaged' || source === 'untracked') {
+        return Object.freeze({
+            stageFile: true,
+            unstageFile: false,
+            stageHunk: false,
+            unstageHunk: false,
+            stageLines: false,
+            reason: hunkWritesUnavailable,
+        });
+    }
+    return Object.freeze({
+        stageFile: false,
+        unstageFile: false,
+        stageHunk: false,
+        unstageHunk: false,
+        stageLines: false,
+        reason: '冲突文件本版不提供一键解决，请在 Files 打开处理。',
+    });
+}
+function parseGitDiffDocument(input) {
+    const kind = detectKind(input.lines);
+    const binary = kind === 'binary';
+    const meta = [];
+    const hunks = [];
+    let additions = 0;
+    let deletions = 0;
+    let current;
+    const closeHunk = () => {
+        if (!current)
+            return;
+        const hunkId = `${current.index}:${current.oldStart}:${current.newStart}`;
+        // A hunk is complete when it accounts for every line its header promised. The final
+        // hunk of a paged read is reported incomplete so callers cannot write a partial patch.
+        const consumedOld = current.oldCursor - current.oldStart;
+        const consumedNew = current.newCursor - current.newStart;
+        const reached = consumedOld >= current.oldLines && consumedNew >= current.newLines;
+        hunks.push(Object.freeze({
+            hunkId,
+            header: current.header,
+            oldStart: current.oldStart,
+            oldLines: current.oldLines,
+            newStart: current.newStart,
+            newLines: current.newLines,
+            contextLabel: current.contextLabel,
+            lines: Object.freeze(current.lines),
+            complete: reached,
+        }));
+        current = undefined;
+    };
+    for (const raw of input.lines) {
+        const headerMatch = HUNK_HEADER.exec(raw);
+        if (headerMatch) {
+            closeHunk();
+            const oldStart = Number(headerMatch[1]);
+            const newStart = Number(headerMatch[3]);
+            current = {
+                header: raw,
+                oldStart,
+                oldLines: headerMatch[2] === undefined ? 1 : Number(headerMatch[2]),
+                newStart,
+                newLines: headerMatch[4] === undefined ? 1 : Number(headerMatch[4]),
+                contextLabel: (headerMatch[5] ?? '').trim(),
+                lines: [],
+                oldCursor: oldStart,
+                newCursor: newStart,
+                index: hunks.length,
+            };
+            continue;
+        }
+        if (!current) {
+            // Everything before the first hunk is document metadata.
+            if (raw)
+                meta.push(raw);
+            continue;
+        }
+        if (raw === NO_NEWLINE) {
+            current.lines.push(Object.freeze({
+                lineId: `${current.index}:${current.oldStart}:${current.newStart}#${current.lines.length}`,
+                kind: 'meta',
+                oldLineNumber: null,
+                newLineNumber: null,
+                text: raw,
+                raw,
+            }));
+            continue;
+        }
+        if (isMetaLine(raw)) {
+            // A file boundary inside one page (multi-command reads) closes the current hunk.
+            closeHunk();
+            if (raw)
+                meta.push(raw);
+            continue;
+        }
+        const marker = raw[0];
+        const text = raw.length > 0 ? raw.slice(1) : '';
+        let lineKind;
+        let oldLineNumber = null;
+        let newLineNumber = null;
+        if (marker === '+') {
+            lineKind = 'addition';
+            newLineNumber = current.newCursor;
+            current.newCursor += 1;
+            additions += 1;
+        }
+        else if (marker === '-') {
+            lineKind = 'deletion';
+            oldLineNumber = current.oldCursor;
+            current.oldCursor += 1;
+            deletions += 1;
+        }
+        else if (marker === ' ') {
+            lineKind = 'context';
+            oldLineNumber = current.oldCursor;
+            newLineNumber = current.newCursor;
+            current.oldCursor += 1;
+            current.newCursor += 1;
+        }
+        else if (raw === '') {
+            // An empty line in a hunk body is a context line for an empty source line.
+            lineKind = 'context';
+            oldLineNumber = current.oldCursor;
+            newLineNumber = current.newCursor;
+            current.oldCursor += 1;
+            current.newCursor += 1;
+        }
+        else {
+            lineKind = 'meta';
+        }
+        current.lines.push(Object.freeze({
+            lineId: `${current.index}:${current.oldStart}:${current.newStart}#${current.lines.length}`,
+            kind: lineKind,
+            oldLineNumber,
+            newLineNumber,
+            text,
+            raw,
+        }));
+    }
+    closeHunk();
+    const frozenHunks = Object.freeze(hunks);
+    let completeness = 'complete';
+    if (input.hasMore)
+        completeness = 'paged';
+    else if (frozenHunks.some(hunk => !hunk.complete))
+        completeness = 'limited';
+    return Object.freeze({
+        schemaVersion: 2,
+        fileToken: input.fileToken,
+        // A digest keeps the document self-describing without leaking the raw path shape.
+        path: input.path,
+        source: input.source,
+        repositoryRevision: input.repositoryRevision,
+        kind,
+        binary,
+        hunks: frozenHunks,
+        meta: Object.freeze(meta),
+        completeness,
+        additions,
+        deletions,
+        lineCount: input.lines.length,
+        nextCursor: input.nextCursor,
+        capabilities: capabilitiesFor(input.source),
+    });
+}
+//# sourceMappingURL=git-diff-document.js.map

package/dist/web/git-file-source.d.ts

@@ -0,0 +1,25 @@
+/**
+ * v0.3.17 — Git comparison source.
+ *
+ * Lives in its own module so both the read model service and the diff document parser can
+ * depend on it without forming a cycle. A path with an index change *and* a further
+ * worktree change (`MM`) is two distinct selectable objects, so the source is part of a
+ * Git file identity, not a display attribute.
+ */
+/**
+ * `commit` is not a working-tree state: it identifies a historical comparison (a commit
+ * against its base). Plan §6.1 makes the comparison target a first-class field, so it is a
+ * distinct value rather than being smuggled in as `staged` or a display flag. It is
+ * read-only: no mutation path accepts it (plan G3 keeps history read-only).
+ */
+export type WebGitFileSourceV1 = 'staged' | 'unstaged' | 'untracked' | 'conflict' | 'commit';
+/**
+ * The four sources a `git status` record can belong to. A commit comparison is never a
+ * working-tree state, so status buckets and counts are typed against this narrower set —
+ * adding a comparison source must not force status code to handle an impossible case.
+ */
+export type GitWorktreeSourceV1 = 'staged' | 'unstaged' | 'untracked' | 'conflict';
+export declare const GIT_WORKTREE_SOURCES_V1: readonly GitWorktreeSourceV1[];
+export declare const GIT_FILE_SOURCES_V1: readonly WebGitFileSourceV1[];
+export declare function isGitFileSourceV1(value: unknown): value is WebGitFileSourceV1;
+//# sourceMappingURL=git-file-source.d.ts.map

package/dist/web/git-file-source.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIT_FILE_SOURCES_V1 = exports.GIT_WORKTREE_SOURCES_V1 = void 0;
+exports.isGitFileSourceV1 = isGitFileSourceV1;
+exports.GIT_WORKTREE_SOURCES_V1 = Object.freeze([
+    'staged',
+    'unstaged',
+    'untracked',
+    'conflict',
+]);
+exports.GIT_FILE_SOURCES_V1 = Object.freeze([
+    'staged',
+    'unstaged',
+    'untracked',
+    'conflict',
+    'commit',
+]);
+function isGitFileSourceV1(value) {
+    return (typeof value === 'string' && exports.GIT_FILE_SOURCES_V1.includes(value));
+}
+//# sourceMappingURL=git-file-source.js.map

package/dist/web/git-history-service.d.ts

@@ -0,0 +1,151 @@
+/** `git hash-object -t tree /dev/null` — the canonical empty tree, used for root commits. */
+export declare const GIT_EMPTY_TREE_OID = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+export type GitRefKindV1 = 'branch' | 'tag' | 'remote' | 'other';
+export interface GitRefV1 {
+    /** e.g. `refs/heads/main`, `refs/tags/v1`, `refs/remotes/origin/main`. */
+    readonly name: string;
+    /** Short display form, e.g. `main`, `v1`, `origin/main`. */
+    readonly shortName: string;
+    readonly kind: GitRefKindV1;
+    readonly oid: string;
+    /** True for the ref HEAD points at. */
+    readonly isHead: boolean;
+}
+export interface GitRefsV1 {
+    readonly refs: readonly GitRefV1[];
+    readonly head: string | null;
+    readonly detached: boolean;
+    readonly truncated: boolean;
+}
+export interface GitCommitSummaryV1 {
+    readonly id: string;
+    readonly shortId: string;
+    readonly subject: string;
+    readonly authorName: string;
+    readonly authoredAt: string;
+    /** Parents, first parent first. Empty for a root commit. */
+    readonly parents: readonly string[];
+    /** True when the commit has more than one parent. */
+    readonly isMerge: boolean;
+    /** `%D` decoration, trimmed; never used to infer identity. */
+    readonly decoration: readonly string[];
+}
+export interface GitCommitDetailV1 extends GitCommitSummaryV1 {
+    readonly message: string;
+    readonly committerName: string;
+    readonly committedAt: string;
+    readonly authorEmail: string;
+    /**
+     * The tree the commit is compared against: the first parent, or a caller-chosen parent, or
+     * the empty tree for a root commit. Exposed so the UI states the real comparison.
+     */
+    readonly baseOid: string;
+    readonly baseLabel: string;
+    readonly parentIndex: number;
+}
+export interface GitCommitFileV1 {
+    readonly path: string;
+    /** Rename source, when Git detected one. */
+    readonly renamedFrom: string | null;
+    readonly additions: number;
+    readonly deletions: number;
+    /** True for a binary entry, where numstat reports `-` for both counts. */
+    readonly binary: boolean;
+    readonly sensitive: boolean;
+}
+export interface GitCommitFilesV1 {
+    readonly commitSha: string;
+    readonly baseOid: string;
+    readonly baseLabel: string;
+    readonly files: readonly GitCommitFileV1[];
+    readonly additions: number;
+    readonly deletions: number;
+    readonly truncated: boolean;
+}
+export interface GitHistoryQueryV1 {
+    /** Substring of the commit message. */
+    readonly message?: string;
+    /** Substring of the author name or email. */
+    readonly author?: string;
+    /** Full or abbreviated commit SHA. */
+    readonly sha?: string;
+    /** Restricts to commits touching this path. */
+    readonly path?: string;
+    /** ISO date or `YYYY-MM-DD`; passed through as `--since`/`--until`. */
+    readonly since?: string;
+    readonly until?: string;
+    /** Defaults to HEAD. */
+    readonly rev?: string;
+    readonly cursor?: string;
+    readonly pageSize?: number;
+}
+export interface GitHistoryPageV1 {
+    readonly items: readonly GitCommitSummaryV1[];
+    readonly nextCursor: string | null;
+    /** The tip the page was frozen against, so the UI can state it. */
+    readonly tipOid: string | null;
+    readonly truncated: boolean;
+}
+export interface GitBlameLineV1 {
+    readonly lineNumber: number;
+    readonly commitShort: string;
+    readonly author: string;
+    readonly authoredAt: string;
+    readonly summary: string;
+    /** True when the commit predates the history git can see (a grafted/shallow boundary). */
+    readonly isBoundary: boolean;
+}
+export interface GitBlameResultV1 {
+    readonly path: string;
+    readonly rev: string | null;
+    readonly lines: readonly GitBlameLineV1[];
+    readonly truncated: boolean;
+}
+export interface GitGraphRowV1 {
+    /** The graph column prefix exactly as git drew it (never re-derived by us). */
+    readonly graph: string;
+    /** Commit id when the row belongs to a commit; graph-only rows have null. */
+    readonly id: string | null;
+    readonly shortId: string | null;
+    readonly subject: string;
+}
+export interface GitGraphPageV1 {
+    readonly rows: readonly GitGraphRowV1[];
+    readonly truncated: boolean;
+}
+export interface GitFileHistoryPageV1 {
+    readonly path: string;
+    readonly items: readonly GitCommitSummaryV1[];
+    /** True when Git followed a rename across the boundary; the UI must say so. */
+    readonly followed: boolean;
+    readonly truncated: boolean;
+}
+export interface GitHistoryReader {
+    refs(): Promise<GitRefsV1>;
+    commit(oid: string, parentIndex?: number): Promise<GitCommitDetailV1>;
+    commitFiles(oid: string, parentIndex?: number): Promise<GitCommitFilesV1>;
+    history(query: GitHistoryQueryV1): Promise<GitHistoryPageV1>;
+    graph(input: {
+        readonly limit?: number;
+    }): Promise<GitGraphPageV1>;
+    blame(input: {
+        readonly path: string;
+        readonly rev?: string;
+        readonly limit?: number;
+    }): Promise<GitBlameResultV1>;
+    fileHistory(input: {
+        readonly path: string;
+        readonly rev?: string;
+        readonly limit?: number;
+    }): Promise<GitFileHistoryPageV1>;
+}
+export interface GitHistoryReaderOptions {
+    /** Runs a read-profile git command in the repository root. */
+    readonly runGit: (args: readonly string[]) => Promise<string>;
+    /** Resolves the repository root, throwing when it is unavailable. */
+    readonly requireRoot: () => Promise<string>;
+    /** Current repository state version, used to bind cursors. */
+    readonly revision: () => Promise<string>;
+}
+export declare function createGitHistoryReader(options: GitHistoryReaderOptions): GitHistoryReader;
+//# sourceMappingURL=git-history-service.d.ts.map