@evandu/super-pi 0.1.128 → 0.1.129

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-BvQ3umhR.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B8GInEf1.css">
+    <script type="module" crossorigin src="/assets/index-D_c-CYAr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CXB6U5mz.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/active-memory.d.ts

@@ -24,6 +24,9 @@ export declare class ActiveMemory {
     readonly directory: string;
     private store;
     private runtime;
+    private readonly inverted;
+    private readonly indexedWorkspaces;
+    private readonly indexedMessages;
     readonly notes: MemoryStore;
     private capabilities;
     private reviews;
@@ -62,10 +65,12 @@ export declare class ActiveMemory {
         conversationId: string;
         title: string;
         messageId: string;
-        role: import("./types.js").MessageRole;
+        role: string;
         score: number;
         content: string;
     }[];
+    private ensureIndex;
+    private addToIndex;
     tool(token: string, body: {
         kind?: string;
         query?: string;
@@ -77,7 +82,7 @@ export declare class ActiveMemory {
         conversationId: string;
         title: string;
         messageId: string;
-        role: import("./types.js").MessageRole;
+        role: string;
         score: number;
         content: string;
     }[] | import("./memory.js").MemoryEntry | {
@@ -91,7 +96,7 @@ export declare class ActiveMemory {
             conversationId: string;
             title: string;
             messageId: string;
-            role: import("./types.js").MessageRole;
+            role: string;
             score: number;
             content: string;
         }[];

package/dist/server/active-memory.js

@@ -6,6 +6,9 @@ export class ActiveMemory {
     directory;
     store;
     runtime;
+    inverted = new Map();
+    indexedWorkspaces = new Set();
+    indexedMessages = new Set();
     notes;
     capabilities = new Map();
     reviews = new Map();
@@ -105,7 +108,44 @@ export class ActiveMemory {
         const words = query.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu)?.slice(0, 12) ?? [];
         if (!words.length)
             return [];
-        return this.store.snapshot().conversations.filter(c => c.workspaceId === workspaceId && (!sessionId || c.id === sessionId)).flatMap(c => c.messages.filter(m => m.role === "user" || m.role === "assistant").map(m => ({ conversationId: c.id, title: c.title, messageId: m.id, role: m.role, content: m.content, score: words.reduce((n, word) => n + (m.content.toLocaleLowerCase().includes(word) ? 1 : 0), 0) }))).filter(m => m.score > 0).sort((a, b) => b.score - a.score).slice(0, 6).map(m => ({ ...m, content: m.content.slice(0, 1200) }));
+        this.ensureIndex(workspaceId);
+        const candidates = new Map();
+        for (const word of words)
+            for (const [id, value] of this.inverted.get(workspaceId)?.get(word) ?? [])
+                void id, candidates.set(value.messageId, value);
+        return [...candidates.values()].filter(m => !sessionId || m.conversationId === sessionId).map(m => ({ ...m, score: words.reduce((n, word) => n + (m.content.toLocaleLowerCase().includes(word) ? 1 : 0), 0) })).filter(m => m.score > 0).sort((a, b) => b.score - a.score).slice(0, 6).map(m => ({ ...m, content: m.content.slice(0, 1200) }));
+    }
+    ensureIndex(workspaceId) {
+        if (this.indexedWorkspaces.has(workspaceId))
+            return;
+        const index = new Map();
+        for (const conversation of this.store.snapshot().conversations.filter(c => c.workspaceId === workspaceId))
+            for (const message of conversation.messages) {
+                if (message.role !== "user" && message.role !== "assistant")
+                    continue;
+                const value = { conversationId: conversation.id, title: conversation.title, messageId: message.id, role: message.role, content: message.content };
+                this.indexedMessages.add(message.id);
+                for (const word of message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []) {
+                    let bucket = index.get(word);
+                    if (!bucket)
+                        index.set(word, bucket = new Map());
+                    bucket.set(message.id, value);
+                }
+            }
+        this.inverted.set(workspaceId, index);
+        this.indexedWorkspaces.add(workspaceId);
+    }
+    addToIndex(conversation, message) {
+        if (!this.indexedWorkspaces.has(conversation.workspaceId) || (message.role !== "user" && message.role !== "assistant"))
+            return;
+        let terms = this.inverted.get(conversation.workspaceId);
+        const value = { conversationId: conversation.id, title: conversation.title, messageId: message.id, role: message.role, content: message.content };
+        for (const term of message.content.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []) {
+            let bucket = terms.get(term);
+            if (!bucket)
+                terms.set(term, bucket = new Map());
+            bucket.set(message.id, value);
+        }
     }
     async tool(token, body) {
         const identity = this.identity(token);
@@ -202,6 +242,9 @@ export class ActiveMemory {
         this.cancel(id); }
     async waitForIdle() { await Promise.allSettled([...this.workspaceReviews.values()]); await this.serial; }
     async completed(conversation) {
+        for (const message of conversation.messages)
+            if (!this.indexedMessages.has(message.id))
+                this.addToIndex(conversation, message);
         const settings = await this.configuration();
         if (!settings.enabled || !settings.reviewInterval)
             return;

package/dist/server/application/run-service.js

@@ -239,7 +239,16 @@ export class RunService {
                 // processes the result" contract, and the auto-triggered turn goes through the same
                 // `composePrompt` path the success case does (so a helper failure surfaces as `state="error"`
                 // prose the agent can react to).
-                if (!this.activeRuns.has(task.conversationId) && !this.interruptTargets.has(task.conversationId)) {
+                const custom = this.runtime.sendCustomMessage;
+                if (custom) {
+                    await custom.call(this.runtime, task.conversationId, {
+                        customType: "super-pi-task-result",
+                        content: body,
+                        display: "后台任务结果",
+                        details: { taskId: sessionId, source: "exec", state: exitCode === 0 ? "completed" : "error", summary: task.title },
+                    });
+                }
+                else if (!this.activeRuns.has(task.conversationId) && !this.interruptTargets.has(task.conversationId)) {
                     void this.processWaitingMessage(task.conversationId, queued.id).catch((error) => {
                         console.warn(`Super Pi: auto-trigger for background exec result failed: ${error instanceof Error ? error.message : "unknown error"}`);
                     });

package/dist/server/git.d.ts

@@ -50,5 +50,92 @@ export declare function gitDiff(root: string, path: string, staged: boolean): Pr
  * version to compare against" - and the third is a refusal, which the caller reports.
  */
 export declare function gitHeadContent(root: string, path: string): Promise<string | null>;
+/**
+ * A file larger than this is refused for blame (`too_large`) rather than blamed. Blame's cost scales
+ * with a text file's LINE count, and a file this size can carry millions of them, so the bound is
+ * checked from `stat` (working tree) or `git cat-file -s` (a revision) BEFORE any content is read -
+ * an oversized file costs one stat, never a buffer.
+ */
+export declare const MAX_BLAME_FILE_BYTES: number;
+/**
+ * The most lines one blame response may carry. `--line-porcelain` emits roughly 300-500 bytes of
+ * metadata per line, so this cap bounds the response and the parse to single-digit megabytes. A
+ * whole-file request for a longer file is answered with the FIRST `MAX_BLAME_LINES` entries and
+ * `truncated: true`; a caller that wants more asks for an explicit `startLine`/`endLine` window -
+ * which is what the gutter does anyway, and a window may not exceed this cap either.
+ */
+export declare const MAX_BLAME_LINES = 20000;
+export type GitBlameLine = {
+    /** 1-based line number in the file AS BLAMED - the working tree by default, or the requested revision. */
+    line: number;
+    commit: string | null;
+    shortCommit: string | null;
+    author: string | null;
+    authorEmail: string | null;
+    /** Author time as an ISO instant, or `null` when git did not supply a parseable one. */
+    date: string | null;
+    /** First line of the commit message. */
+    summary: string | null;
+    /** The line differs from the blame anchor and exists only in the working tree - git reported the
+     *  all-zero commit for it. Such lines carry `null` for every other field: there is no commit to
+     *  name, and inventing "Not Committed Yet" placeholders would put git's English prose into a
+     *  structured contract the client is meant to phrase in its own words. */
+    isUncommitted: boolean;
+};
+/** Why blame is not available for a file that otherwise exists. Reported as `supported: false` inside
+ *  a 200, NOT thrown: these are facts about the file or repository a gutter renders as a state word,
+ *  not request errors. (`not_a_repo` is deliberately NOT one of these - it is thrown, so it maps to
+ *  the same 404 the other /api/git ops return, per the endpoint's one shared error vocabulary.) */
+export type GitBlameUnsupportedReason = "untracked" | "binary" | "too_large" | "no_head" | "not_in_revision";
+export type GitBlameResponse = {
+    /** Workspace-relative path, always `/`-separated: the canonical form of what was requested, not an
+     *  echo of it - `sub\inner.txt` and `sub/../sub/inner.txt` both come back as `sub/inner.txt`. */
+    path: string;
+    /** The revision blame was anchored to: the requested one, or `"HEAD"` for the default - which blames
+     *  the WORKING TREE, which is why uncommitted lines can appear (flagged `isUncommitted`). */
+    revision: string;
+    lines: GitBlameLine[];
+    /** Lines in the file as blamed, including lines outside a requested window. */
+    totalLines: number;
+    /** True when a WHOLE-FILE request was cut at `MAX_BLAME_LINES`. A windowed request is never
+     *  `truncated`: the caller asked for exactly what it got. */
+    truncated: boolean;
+    supported: boolean;
+    reason?: GitBlameUnsupportedReason;
+};
+export type GitBlameOptions = {
+    /** A commit-ish to blame instead of the working tree. Resolved through `rev-parse --verify` before
+     *  anything else uses it; a revision git cannot resolve is a `bad_revision` error. */
+    revision?: string;
+    /** 1-based inclusive window. Both or neither; positive integers; start <= end; end <= totalLines;
+     *  the span may not exceed `MAX_BLAME_LINES`. Violations throw `bad_range` with the bound named. */
+    startLine?: number;
+    endLine?: number;
+    /** RESERVED, currently a no-op: blame follows the requested path name only and does not aggregate
+     *  history across renames. The field exists so a caller can state its intent without this contract
+     *  growing a second shape on the day rename support lands. */
+    follow?: boolean;
+};
+/**
+ * Line-by-line provenance for one file: who last touched each line, in which commit.
+ *
+ * SECURITY BOUNDARY. `path` arrives from a browser and is contained exactly as `gitDiff` and
+ * `gitHeadContent` contain it - resolve against the workspace root, refuse anything that lands
+ * outside. Backslashes are normalised to `/` FIRST, so a Windows-spelled relative path resolves like
+ * the same request spelled with `/` and the git invocation and the response share the one separator
+ * this API speaks. `revision` arrives from the same untrusted place: it may not start with `-` (that
+ * is how an argument becomes a git FLAG) and may not carry whitespace or NUL. Every git call here is
+ * `execFile` with an argument array - no shell, no string interpolation into a command line - and the
+ * path always travels after a bare `--`, so no path can be read as an option.
+ *
+ * FAILURE SHAPE. Facts about the file or repository (`untracked`, `binary`, `too_large`, `no_head`,
+ * `not_in_revision`) come back as `supported: false` - the gutter renders them, it does not error on
+ * them. Request mistakes (path escapes, a missing file, a bad revision, an illegal range) throw with
+ * a stable `code` for the HTTP layer to map. Git's raw stderr never reaches a caller: expected
+ * failures are thrown as written sentences, and an unexpected git failure is logged here and thrown
+ * as one stable sentence.
+ */
+export declare function gitBlame(root: string, path: string, options?: GitBlameOptions): Promise<GitBlameResponse>;
 /** Whether the directory is a git repository at all. The review view asks before it offers a git baseline. */
 export declare function isGitRepository(root: string): Promise<boolean>;
+export declare function gitMutate(root: string, op: string, path?: string, message?: string): Promise<GitWorkspace>;

package/dist/server/git.js

@@ -1,9 +1,10 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { basename, resolve, sep } from "node:path";
+import { basename, relative, resolve, sep } from "node:path";
 import { existsSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
 const exec = promisify(execFile);
-async function git(cwd, args) { return exec("git", ["-c", "core.quotepath=false", ...args], { cwd, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }); }
+async function git(cwd, args, options) { return exec("git", ["-c", "core.quotepath=false", ...args], { cwd, windowsHide: true, maxBuffer: options?.maxBuffer ?? 8 * 1024 * 1024 }); }
 function files(raw) { const staged = [], unstaged = [], untracked = []; for (const line of raw.split("\0").filter(Boolean)) {
     const xy = line.slice(0, 2), path = line.slice(3).split("\0")[0].replaceAll("\\", "/");
     const item = { path, name: basename(path), xy };
@@ -63,7 +64,305 @@ export async function gitHeadContent(root, path) {
         return null;
     }
 }
+// ---------------------------------------------------------------------------------------------
+// Git blame.
+//
+// The blame gutter needs, for one file: who last touched each line, and in which commit. Git's
+// `--line-porcelain` output is the only source for that, and this module is the only place allowed
+// to parse it - the caller receives the structured `GitBlameLine[]` and never sees porcelain text,
+// the same boundary `gitLog` already draws for its own format.
+// ---------------------------------------------------------------------------------------------
+/**
+ * A file larger than this is refused for blame (`too_large`) rather than blamed. Blame's cost scales
+ * with a text file's LINE count, and a file this size can carry millions of them, so the bound is
+ * checked from `stat` (working tree) or `git cat-file -s` (a revision) BEFORE any content is read -
+ * an oversized file costs one stat, never a buffer.
+ */
+export const MAX_BLAME_FILE_BYTES = 2 * 1024 * 1024;
+/**
+ * The most lines one blame response may carry. `--line-porcelain` emits roughly 300-500 bytes of
+ * metadata per line, so this cap bounds the response and the parse to single-digit megabytes. A
+ * whole-file request for a longer file is answered with the FIRST `MAX_BLAME_LINES` entries and
+ * `truncated: true`; a caller that wants more asks for an explicit `startLine`/`endLine` window -
+ * which is what the gutter does anyway, and a window may not exceed this cap either.
+ */
+export const MAX_BLAME_LINES = 20000;
+/** Output-buffer headroom for the blame process itself: MAX_BLAME_LINES records at ~500 bytes each is
+ *  ~10MB, and 32MB leaves slack for long author names and summaries without being unbounded. */
+const BLAME_MAX_BUFFER = 32 * 1024 * 1024;
+/** How many leading bytes are sniffed for a NUL byte to classify content as binary - the same
+ *  heuristic git's own diff machinery uses. A NUL byte cannot appear in UTF-8 text; a binary file's
+ *  "lines" are meaningless to a gutter, and git blame happily produces metadata for them, so the
+ *  refusal has to happen here, before the porcelain is ever asked for. */
+const BLAME_SNIFF_BYTES = 8192;
+function unsupportedBlame(path, revision, reason) {
+    return { path, revision, lines: [], totalLines: 0, truncated: false, supported: false, reason };
+}
+/** `\n`-delimited line count: a trailing newline does not open a line of its own, an empty file has
+ *  none, and a lone `\n` is one (empty) line - matching what git blame itself will report. */
+function countTextLines(text) {
+    if (text.length === 0)
+        return 0;
+    let count = 1;
+    for (let i = 0; i < text.length; i++)
+        if (text.charCodeAt(i) === 10)
+            count++;
+    if (text.charCodeAt(text.length - 1) === 10)
+        count--;
+    return count;
+}
+/**
+ * One porcelain record per line: `<40-hex sha> <orig-line> <final-line> [<count>]`, followed by the
+ * full header (`author`, `author-mail`, `author-time`, `summary`, `filename`, ...), followed by the
+ * line's own content prefixed with TAB. `--line-porcelain` repeats the full header for EVERY line, so
+ * parsing is stateless per record - no carry-over of "the commit from the previous record", which is
+ * the bug plain `--porcelain` invites. Two rules make the parse safe:
+ *
+ * 1. A record header is a 40-hex sha followed by two decimal numbers, and nothing else in the stream
+ *    matches that - every other line is either `key value` metadata or TAB-prefixed content. The
+ *    optional fourth number is the porcelain GROUP size (a run of consecutive lines from one commit);
+ *    under `--line-porcelain` every line still gets its own record, so it is parsed and discarded.
+ * 2. The TAB-prefixed content line is skipped UNREAD. It is the one part of the stream that can hold
+ *    arbitrary file bytes - NULs, line-splitting illusions, huge runs - and this API's contract is
+ *    metadata only.
+ */
+function parseBlamePorcelain(raw) {
+    const lines = [];
+    let current = null;
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("\t"))
+            continue;
+        const header = /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/.exec(line);
+        if (header) {
+            const sha = header[1];
+            const uncommitted = /^0{40}$/.test(sha);
+            current = {
+                line: Number(header[3]),
+                commit: uncommitted ? null : sha,
+                shortCommit: uncommitted ? null : sha.slice(0, 8),
+                author: null, authorEmail: null, date: null, summary: null,
+                isUncommitted: uncommitted,
+            };
+            lines.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        // An uncommitted record still carries git's placeholders in its metadata ("Not Committed Yet", a
+        // pseudo address, the time of the diff run); the contract nulls every field but the flag, so that
+        // metadata is skipped rather than copied into the response.
+        if (current.isUncommitted)
+            continue;
+        const space = line.indexOf(" ");
+        const key = space === -1 ? line : line.slice(0, space);
+        const value = space === -1 ? "" : line.slice(space + 1);
+        if (key === "author")
+            current.author = value;
+        else if (key === "author-mail")
+            current.authorEmail = value.startsWith("<") && value.endsWith(">") ? value.slice(1, -1) : value;
+        else if (key === "author-time") {
+            const ms = Number(value) * 1000;
+            if (Number.isFinite(ms))
+                current.date = new Date(ms).toISOString();
+        }
+        else if (key === "summary")
+            current.summary = value;
+    }
+    return lines;
+}
+/**
+ * Line-by-line provenance for one file: who last touched each line, in which commit.
+ *
+ * SECURITY BOUNDARY. `path` arrives from a browser and is contained exactly as `gitDiff` and
+ * `gitHeadContent` contain it - resolve against the workspace root, refuse anything that lands
+ * outside. Backslashes are normalised to `/` FIRST, so a Windows-spelled relative path resolves like
+ * the same request spelled with `/` and the git invocation and the response share the one separator
+ * this API speaks. `revision` arrives from the same untrusted place: it may not start with `-` (that
+ * is how an argument becomes a git FLAG) and may not carry whitespace or NUL. Every git call here is
+ * `execFile` with an argument array - no shell, no string interpolation into a command line - and the
+ * path always travels after a bare `--`, so no path can be read as an option.
+ *
+ * FAILURE SHAPE. Facts about the file or repository (`untracked`, `binary`, `too_large`, `no_head`,
+ * `not_in_revision`) come back as `supported: false` - the gutter renders them, it does not error on
+ * them. Request mistakes (path escapes, a missing file, a bad revision, an illegal range) throw with
+ * a stable `code` for the HTTP layer to map. Git's raw stderr never reaches a caller: expected
+ * failures are thrown as written sentences, and an unexpected git failure is logged here and thrown
+ * as one stable sentence.
+ */
+export async function gitBlame(root, path, options = {}) {
+    const relativePath = path.replaceAll("\\", "/");
+    if (!relativePath || relativePath.endsWith("/") || relativePath.includes("\0")) {
+        throw Object.assign(new Error("文件路径无效"), { code: "path" });
+    }
+    const safe = resolve(root, relativePath);
+    if (!safe.startsWith(resolve(root) + sep))
+        throw Object.assign(new Error("文件路径无效"), { code: "path" });
+    // The canonical `/`-separated form the response echoes - `sub\inner.txt` and `sub/../sub/inner.txt`
+    // both normalise to `sub/inner.txt`, so the client cannot learn a second spelling of one file.
+    const canonical = relative(resolve(root), safe).split(sep).join("/");
+    const isRepo = await git(root, ["rev-parse", "--git-dir"]).then(() => true).catch(() => false);
+    if (!isRepo)
+        throw Object.assign(new Error("此工作区不是 Git 仓库"), { code: "not_a_repo" });
+    const revision = options.revision?.trim() || undefined;
+    if (revision && (revision.startsWith("-") || /[\s\0]/.test(revision))) {
+        throw Object.assign(new Error("无效的 revision"), { code: "bad_revision" });
+    }
+    // An unborn repository has no commit for ANY line to point at, so blame is uniformly unavailable
+    // (`no_head`, a supported:false fact) rather than an error - the repository itself is fine, it just
+    // has no history yet. Checked before trackedness: the answer does not depend on the file.
+    if (!revision) {
+        const hasHead = await git(root, ["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false);
+        if (!hasHead)
+            return unsupportedBlame(canonical, "HEAD", "no_head");
+    }
+    // Resolve the anchor to a concrete commit BEFORE anything else uses it - this is what splits "the
+    // revision is bogus" (bad_revision) from "the file is not in that revision" (not_in_revision):
+    // both are git exit 128, and only ordering gives them distinct, stable codes.
+    let revSha;
+    if (revision) {
+        const resolved = await git(root, ["rev-parse", "--verify", `${revision}^{commit}`]).then((r) => r.stdout.trim()).catch(() => null);
+        if (!resolved)
+            throw Object.assign(new Error(`无法解析 revision：${revision}`), { code: "bad_revision" });
+        revSha = resolved;
+    }
+    // Trackedness is judged against the index, exactly as `gitDiff` judges it, so every op answers the
+    // same question the same way. A file on disk that the index has never heard of is `untracked` (a
+    // supported:false fact - the file is real and the gutter may well be showing it). A path that does
+    // not exist at all is an ERROR (`not_found`), deliberately distinct from `untracked`: "git does not
+    // know this file" and "there is no such file" are different sentences. A file tracked but deleted
+    // from the working tree is `not_found` for the default anchor - which reads the working tree, and
+    // git itself refuses with `Cannot lstat` there - while an explicit revision does not need the
+    // working-tree file at all and is allowed through.
+    const tracked = await git(root, ["ls-files", "--error-unmatch", "--", relativePath]).then(() => true).catch(() => false);
+    const onDisk = existsSync(safe);
+    if (!tracked && !onDisk)
+        throw Object.assign(new Error(`文件不存在：${canonical}`), { code: "not_found" });
+    if (!tracked)
+        return unsupportedBlame(canonical, revision ?? "HEAD", "untracked");
+    if (!onDisk && !revision)
+        throw Object.assign(new Error(`文件不存在：${canonical}（已从工作区删除）`), { code: "not_found" });
+    // Size, binary sniff and line count, from the content blame will actually read: the committed blob
+    // for an explicit revision, the working-tree file for the default anchor. One bounded read (capped
+    // above at MAX_BLAME_FILE_BYTES) yields all three, so no request ever streams an unbounded file
+    // into memory just to count it.
+    let content;
+    if (revSha) {
+        const size = await git(root, ["cat-file", "-s", `${revSha}:${relativePath}`]).then((r) => Number(r.stdout.trim())).catch(() => null);
+        if (size === null)
+            return unsupportedBlame(canonical, revision ?? "HEAD", "not_in_revision");
+        if (size > MAX_BLAME_FILE_BYTES)
+            return unsupportedBlame(canonical, revision ?? "HEAD", "too_large");
+        const blob = await git(root, ["cat-file", "blob", `${revSha}:${relativePath}`]).catch(() => null);
+        if (blob === null)
+            return unsupportedBlame(canonical, revision ?? "HEAD", "not_in_revision");
+        content = Buffer.from(blob.stdout, "utf8");
+    }
+    else {
+        try {
+            const info = await stat(safe);
+            if (info.size > MAX_BLAME_FILE_BYTES)
+                return unsupportedBlame(canonical, "HEAD", "too_large");
+            content = await readFile(safe);
+        }
+        catch {
+            // The file vanished between the existsSync above and this read - the same not_found, reached
+            // through a race instead of a pre-check.
+            throw Object.assign(new Error(`文件不存在：${canonical}`), { code: "not_found" });
+        }
+    }
+    const sniffEnd = Math.min(content.length, BLAME_SNIFF_BYTES);
+    for (let i = 0; i < sniffEnd; i++)
+        if (content[i] === 0)
+            return unsupportedBlame(canonical, revision ?? "HEAD", "binary");
+    const totalLines = countTextLines(content.toString("utf8"));
+    // The window. Validated strictly and AFTER totalLines is known, so each rejection can name the real
+    // bound ("the file has 12 lines") instead of a guess.
+    const startRaw = options.startLine;
+    const endRaw = options.endLine;
+    if ((startRaw === undefined) !== (endRaw === undefined)) {
+        throw Object.assign(new Error("startLine 与 endLine 必须同时提供"), { code: "bad_range" });
+    }
+    let start = 1;
+    let end = totalLines;
+    let windowed = false;
+    if (startRaw !== undefined && endRaw !== undefined) {
+        windowed = true;
+        if (!Number.isInteger(startRaw) || startRaw < 1)
+            throw Object.assign(new Error(`startLine 必须是正整数，收到 ${startRaw}`), { code: "bad_range" });
+        if (!Number.isInteger(endRaw) || endRaw < 1)
+            throw Object.assign(new Error(`endLine 必须是正整数，收到 ${endRaw}`), { code: "bad_range" });
+        if (startRaw > endRaw)
+            throw Object.assign(new Error(`startLine (${startRaw}) 不能大于 endLine (${endRaw})`), { code: "bad_range" });
+        if (endRaw > totalLines)
+            throw Object.assign(new Error(`endLine (${endRaw}) 超出文件行数 (${totalLines})`), { code: "bad_range" });
+        if (endRaw - startRaw + 1 > MAX_BLAME_LINES)
+            throw Object.assign(new Error(`行范围过大：单次最多 ${MAX_BLAME_LINES} 行`), { code: "bad_range" });
+        start = startRaw;
+        end = endRaw;
+    }
+    else if (totalLines > MAX_BLAME_LINES) {
+        // A whole-file request on an over-cap file is answered with the head of the file and `truncated`.
+        // The gutter asks in windows and never hits this; the prefix exists so a naive caller gets useful
+        // data rather than a refusal or an unbounded response.
+        end = MAX_BLAME_LINES;
+    }
+    const args = ["blame", "--line-porcelain"];
+    if (start !== 1 || end !== totalLines)
+        args.push("-L", `${start},${end}`);
+    if (revSha)
+        args.push(revSha);
+    args.push("--", relativePath);
+    let raw;
+    try {
+        raw = (await git(root, args, { maxBuffer: BLAME_MAX_BUFFER })).stdout;
+    }
+    catch (error) {
+        // Git's stderr is for this server's log, not for the user: an unexpected blame failure surfaces
+        // as one stable sentence with a stable code, and the raw output stays server-side.
+        console.error(`git blame failed for ${canonical}:`, error);
+        throw Object.assign(new Error("git blame 执行失败"), { code: "git_error" });
+    }
+    return {
+        path: canonical,
+        revision: revision ?? "HEAD",
+        lines: parseBlamePorcelain(raw),
+        totalLines,
+        truncated: !windowed && totalLines > MAX_BLAME_LINES,
+        supported: true,
+    };
+}
 /** Whether the directory is a git repository at all. The review view asks before it offers a git baseline. */
 export async function isGitRepository(root) {
     return git(root, ["rev-parse", "--git-dir"]).then(() => true).catch(() => false);
 }
+function safePath(root, path) {
+    const safe = resolve(root, path);
+    if (safe !== resolve(root) && !safe.startsWith(resolve(root) + sep))
+        throw Object.assign(new Error("文件路径无效"), { code: "path" });
+    return path;
+}
+export async function gitMutate(root, op, path, message) {
+    if (op === "stage" || op === "unstage" || op === "discard") {
+        if (!path)
+            throw Object.assign(new Error("缺少文件路径"), { code: "path" });
+        safePath(root, path);
+        if (op === "stage")
+            await git(root, ["add", "--", path]);
+        else if (op === "unstage")
+            await git(root, ["restore", "--staged", "--", path]);
+        else
+            await git(root, ["restore", "--", path]);
+    }
+    else if (op === "commit") {
+        if (!message?.trim())
+            throw Object.assign(new Error("提交消息不能为空"), { code: "bad_message" });
+        await git(root, ["commit", "-m", message.trim()]);
+    }
+    else if (op === "pull")
+        await git(root, ["pull", "--ff-only"]);
+    else if (op === "push")
+        await git(root, ["push"]);
+    else
+        throw Object.assign(new Error("未知 Git 操作"), { code: "bad_op" });
+    return gitStatus(root);
+}

package/dist/server/http-server.js

@@ -7,7 +7,7 @@ import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
 import { checkDiskVersion } from "./version.js";
-import { gitDiff, gitLog, gitStatus } from "./git.js";
+import { gitBlame, gitDiff, gitLog, gitMutate, gitStatus } from "./git.js";
 import { computeFileDiff } from "./file-diff.js";
 import { MAX_KNOWLEDGE_REQUEST_BYTES } from "./knowledge.js";
 import { MAX_TOOL_BODY_BYTES } from "./tool-registry.js";
@@ -797,10 +797,6 @@ export function createHttpServer(options) {
         if (url.pathname === "/api/git") {
             const json = (status, body) => response.writeHead(status, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(body));
             try {
-                if (request.method !== "GET") {
-                    json(405, { error: "Git 视图需要 GET", code: "method" });
-                    return;
-                }
                 const workspaceId = url.searchParams.get("workspaceId");
                 const workspace = context.store.snapshot().workspaces.find((item) => item.id === workspaceId);
                 if (!workspace) {
@@ -808,6 +804,24 @@ export function createHttpServer(options) {
                     return;
                 }
                 const op = url.searchParams.get("op") ?? "status";
+                // Blame is a read with a GET shape: every other verb is refused HERE, before the POST branch
+                // could ever route the op into gitMutate and before any body is read.
+                if (op === "blame" && request.method !== "GET") {
+                    json(405, { error: "Git 请求方法不支持", code: "method" });
+                    return;
+                }
+                if (request.method === "POST") {
+                    let raw = "";
+                    for await (const chunk of request)
+                        raw += chunk;
+                    const body = raw ? JSON.parse(raw) : {};
+                    json(200, await gitMutate(workspace.path, op, body.path, body.message));
+                    return;
+                }
+                if (request.method !== "GET") {
+                    json(405, { error: "Git 请求方法不支持", code: "method" });
+                    return;
+                }
                 if (op === "status")
                     json(200, await gitStatus(workspace.path));
                 else if (op === "log")
@@ -820,6 +834,20 @@ export function createHttpServer(options) {
                     }
                     json(200, await gitDiff(workspace.path, path, url.searchParams.get("staged") === "1"));
                 }
+                else if (op === "blame") {
+                    const path = url.searchParams.get("path");
+                    if (!path) {
+                        json(400, { error: "blame 需要 path", code: "bad_path" });
+                        return;
+                    }
+                    const startLine = url.searchParams.get("startLine");
+                    const endLine = url.searchParams.get("endLine");
+                    json(200, await gitBlame(workspace.path, path, {
+                        revision: url.searchParams.get("revision") ?? undefined,
+                        startLine: startLine === null ? undefined : Number(startLine),
+                        endLine: endLine === null ? undefined : Number(endLine),
+                    }));
+                }
                 else
                     json(400, { error: "未知 Git 操作", code: "bad_op" });
             }
@@ -830,6 +858,10 @@ export function createHttpServer(options) {
                     json(404, { error: "此工作区不是 git 仓库", code: "not_a_repo" });
                 else if (code === "path")
                     json(400, { error: message, code: "bad_path" });
+                else if (code === "not_found")
+                    json(404, { error: message, code: "not_found" });
+                else if (code === "bad_range" || code === "bad_revision")
+                    json(400, { error: message, code });
                 else
                     json(400, { error: message, code: "git_error" });
             }
@@ -900,7 +932,7 @@ export function createHttpServer(options) {
                 json(400, { error: "请求体不是合法的 JSON。" });
                 return;
             }
-            const { cmd, cwd, conversationId, capability, toolCallId } = body;
+            const { cmd, description, cwd, conversationId, capability, toolCallId } = body;
             if (!cmd || !cwd || !conversationId) {
                 json(400, { error: "需要 cmd、cwd 和 conversationId。" });
                 return;
@@ -929,7 +961,7 @@ export function createHttpServer(options) {
             await store.setBackgroundTask({
                 id: sessionId,
                 conversationId,
-                title: cmd.length > 60 ? cmd.slice(0, 60) + "…" : cmd,
+                title: description?.trim() || (cmd.length > 60 ? cmd.slice(0, 60) + "…" : cmd),
                 agentId: "exec",
                 status: "running",
                 startedAt: new Date().toISOString(),