@orion-agents/orion-code 0.3.15 → 0.3.17

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