feat(lanes): stage/undo one hunk at a time, sticky review file headers
Review and the single-file view gain per-hunk Stage and Undo (stage-hunk / discard-hunk: the hunk is named by its @@ line and re-matched against a fresh diff, then git apply --cached / -R; undo needs confirm: true and two clicks). Each review file header stays pinned while its diff scrolls and carries the file's own stage/unstage/discard.
This commit is contained in:
+1
-1
@@ -531,7 +531,7 @@ Request body shape:
|
||||
| `GET` | `/api/lanes/:id/git/ls?q=` | Tracked paths matching a substring, for quick-open. `git ls-files`, so ignored files never appear. Capped at 500. |
|
||||
| `GET` | `/api/lanes/:id/git/tree?path=` | One directory level of tracked files, folded. `400 EBADPATH` for a path escaping the lane. |
|
||||
| `GET` | `/api/lanes/:id/git/branches` | The lane repo's own local branches + worktrees, for the branch switcher. The repo comes from the lane row, never the query. |
|
||||
| `POST` | `/api/lanes/:id/git/:action` | Same-origin guarded git write, serialized under the lane lock: `fetch`, `pull` (always `--ff-only`), `push` (`-u origin HEAD`), `stage`/`unstage`/`discard` (per file; a path must be one git reports changed, and `discard` needs `confirm:true`), `commit` (`add -A` + `-m`, or `only:"staged"`), `switch` (refuses a dirty tree), `branch-create` (never switches) and `branch-delete` (`-d`, refuses protected/current/busy branches). No merge/rebase/reset/stash by design. |
|
||||
| `POST` | `/api/lanes/:id/git/:action` | Same-origin guarded git write, serialized under the lane lock: `fetch`, `pull` (always `--ff-only`), `push` (`-u origin HEAD`), `stage`/`unstage`/`discard` (per file; a path must be one git reports changed, and `discard` needs `confirm:true`), `stage-hunk`/`discard-hunk` (one hunk by its `@@` line, re-read fresh — `409 EHUNKGONE` when it moved; `discard-hunk` needs `confirm:true`), `commit` (`add -A` + `-m`, or `only:"staged"`), `switch` (refuses a dirty tree), `branch-create` (never switches) and `branch-delete` (`-d`, refuses protected/current/busy branches). No merge/rebase/reset/stash by design. |
|
||||
|
||||
The route accepts `{ sourceRepo, title, base?, slug? }`. `sourceRepo` must be
|
||||
an existing absolute git repository. The response lane starts as
|
||||
|
||||
@@ -569,3 +569,67 @@ describe("runGitAction — per-file staging, discard and branches", () => {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("runGitAction — one hunk at a time", () => {
|
||||
beforeEach(freshFixture);
|
||||
|
||||
/** A 20-line file edited at both ends: two hunks at the default context. */
|
||||
function twoHunks() {
|
||||
const lines = Array.from({ length: 20 }, (_, i) => `line ${i + 1}`);
|
||||
write(LANE, "big.txt", lines.join("\n") + "\n");
|
||||
gc(LANE, "add", "big.txt");
|
||||
gc(LANE, "commit", "-qm", "big");
|
||||
lines[0] = "FIRST";
|
||||
lines[19] = "LAST";
|
||||
write(LANE, "big.txt", lines.join("\n") + "\n");
|
||||
}
|
||||
const headers = async () =>
|
||||
(await collectChanges(LANE, { range: "work", file: "big.txt" })).files[0].hunks.map(
|
||||
(h) => h.header
|
||||
);
|
||||
|
||||
it("stages ONE hunk, leaving the other in the working tree", async () => {
|
||||
twoHunks();
|
||||
const [first] = await headers();
|
||||
await runGitAction(LANE, "stage-hunk", { path: "big.txt", hunk: first });
|
||||
const staged = g(LANE, "diff", "--cached", "--", "big.txt");
|
||||
const unstaged = g(LANE, "diff", "--", "big.txt");
|
||||
assert.match(staged, /\+FIRST/);
|
||||
assert.doesNotMatch(staged, /LAST/);
|
||||
assert.match(unstaged, /\+LAST/);
|
||||
assert.doesNotMatch(unstaged, /FIRST/);
|
||||
});
|
||||
|
||||
it("undoes ONE hunk in the working tree, only with confirm", async () => {
|
||||
twoHunks();
|
||||
const [, second] = await headers();
|
||||
await assert.rejects(
|
||||
() => runGitAction(LANE, "discard-hunk", { path: "big.txt", hunk: second }),
|
||||
{ code: "ECONFIRM" }
|
||||
);
|
||||
await runGitAction(LANE, "discard-hunk", { path: "big.txt", hunk: second, confirm: true });
|
||||
const text = fs.readFileSync(path.join(LANE, "big.txt"), "utf8");
|
||||
assert.match(text, /^FIRST\n/);
|
||||
assert.match(text, /line 20\n$/);
|
||||
});
|
||||
|
||||
it("refuses a hunk that is no longer in the diff, and a path that is not changed", async () => {
|
||||
twoHunks();
|
||||
await assert.rejects(
|
||||
() => runGitAction(LANE, "stage-hunk", { path: "big.txt", hunk: "@@ -1,9 +1,9 @@" }),
|
||||
{ code: "EHUNKGONE" }
|
||||
);
|
||||
await assert.rejects(
|
||||
() => runGitAction(LANE, "stage-hunk", { path: "keep.txt", hunk: "@@ -1 +1 @@" }),
|
||||
{ code: "EBADPATH" }
|
||||
);
|
||||
});
|
||||
|
||||
it("sends an untracked file to the per-file actions", async () => {
|
||||
write(LANE, "new.txt", "x\n");
|
||||
await assert.rejects(
|
||||
() => runGitAction(LANE, "stage-hunk", { path: "new.txt", hunk: "@@ -0,0 +1,1 @@" }),
|
||||
{ code: "EUNTRACKED" }
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -785,6 +785,37 @@ async function listTree(dir, { subdir = "" } = {}) {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* ONE hunk of a tracked file's working-copy diff (`git diff HEAD`, the same
|
||||
* read the Changes panel shows), as a standalone patch `git apply` accepts:
|
||||
* the file's own header lines plus that hunk. The hunk is named by its `@@`
|
||||
* line and matched against a FRESH diff at the caller's context, so what gets
|
||||
* applied is always git's own text of the current tree — never a patch a
|
||||
* request carried. Null when no hunk matches (the tree moved on, or the file
|
||||
* is a secret, binary or too large to read whole).
|
||||
*/
|
||||
async function hunkPatch(dir, file, header, context) {
|
||||
if (!header || (await isSecretOnDisk(dir, file))) return null;
|
||||
const u = `-U${normalizeContext(context)}`;
|
||||
const raw = await readCapped(
|
||||
dir,
|
||||
["diff", u, "HEAD", "--no-color", "--no-ext-diff", "--", file],
|
||||
MAX_FILE_BYTES
|
||||
).catch(() => "");
|
||||
// A capped read may end mid-hunk; applying half a hunk is worse than none.
|
||||
if (!raw || raw.length >= MAX_FILE_BYTES) return null;
|
||||
const at = raw.indexOf("\n@@ ");
|
||||
if (at < 0) return null;
|
||||
const head = raw.slice(0, at + 1);
|
||||
// A content line starts with " ", "+", "-" or "\\" — never "@@" — so every
|
||||
// line that does is a hunk boundary.
|
||||
const hunk = raw
|
||||
.slice(at + 1)
|
||||
.split(/^(?=@@ )/m)
|
||||
.find((h) => h.slice(0, h.indexOf("\n")) === header);
|
||||
return hunk ? head + (hunk.endsWith("\n") ? hunk : `${hunk}\n`) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Every level of the tracked tree from ONE `git ls-files`, keyed by directory
|
||||
* path ("" is the root), each level shaped and capped exactly like
|
||||
@@ -824,6 +855,7 @@ async function listTreeAll(dir) {
|
||||
|
||||
module.exports = {
|
||||
collectChanges,
|
||||
hunkPatch,
|
||||
laneStatus,
|
||||
listCommits,
|
||||
listPaths,
|
||||
|
||||
+40
-1
@@ -29,6 +29,9 @@
|
||||
* @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
|
||||
*/
|
||||
|
||||
const fs = require("node:fs");
|
||||
const os = require("node:os");
|
||||
const path = require("node:path");
|
||||
const {
|
||||
git: rawGit,
|
||||
isValidBranchName,
|
||||
@@ -36,7 +39,7 @@ const {
|
||||
branchCheckedOutAt,
|
||||
statusCounts,
|
||||
} = require("./worktree");
|
||||
const { laneStatus } = require("./git-diff");
|
||||
const { hunkPatch, laneStatus } = require("./git-diff");
|
||||
|
||||
const git = (dir, args, opts) => rawGit(dir, args, { literal: true, ...opts });
|
||||
|
||||
@@ -54,6 +57,8 @@ const ACTIONS = new Set([
|
||||
"stage",
|
||||
"unstage",
|
||||
"discard",
|
||||
"stage-hunk",
|
||||
"discard-hunk",
|
||||
"branch-create",
|
||||
"branch-delete",
|
||||
]);
|
||||
@@ -240,6 +245,40 @@ async function runGitAction(dir, action, body = {}) {
|
||||
return done(action, mergeResults(out));
|
||||
}
|
||||
|
||||
if (action === "stage-hunk" || action === "discard-hunk") {
|
||||
// Undoing a hunk is as irreversible as discarding a file: same gate.
|
||||
if (action === "discard-hunk" && body.confirm !== true) {
|
||||
throw bad("ECONFIRM", "discard-hunk requires confirm: true");
|
||||
}
|
||||
const [target] = await resolvePaths(dir, { path: body.path });
|
||||
if (target.code === "??") {
|
||||
throw bad("EUNTRACKED", "an untracked file has no hunks; stage or discard the whole file");
|
||||
}
|
||||
const patch = await hunkPatch(
|
||||
dir,
|
||||
target.path,
|
||||
typeof body.hunk === "string" ? body.hunk : "",
|
||||
body.context
|
||||
);
|
||||
if (!patch) throw bad("EHUNKGONE", "that change is no longer in the diff; refresh and retry");
|
||||
// The patch names paths from the repo root, so it is applied there.
|
||||
const top = (await git(dir, ["rev-parse", "--show-toplevel"])).stdout.trim();
|
||||
const tmp = await fs.promises.mkdtemp(path.join(os.tmpdir(), "agenthub-hunk-"));
|
||||
const file = path.join(tmp, "hunk.patch");
|
||||
try {
|
||||
await fs.promises.writeFile(file, patch);
|
||||
const zero = Number(body.context) === 0 ? ["--unidiff-zero"] : [];
|
||||
// stage: HEAD -> worktree hunk onto the index; undo: the same hunk,
|
||||
// reversed, off the working tree. A hunk the index or tree no longer
|
||||
// matches fails in git's own words (409), never half-applies.
|
||||
const args =
|
||||
action === "stage-hunk" ? ["apply", "--cached", ...zero] : ["apply", "-R", ...zero];
|
||||
return done(action, await git(top, [...args, file]));
|
||||
} finally {
|
||||
await fs.promises.rm(tmp, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
if (action === "commit") {
|
||||
const message = typeof body.message === "string" ? body.message.trim() : "";
|
||||
if (!message) throw bad("EBADMESSAGE", "commit message is required");
|
||||
|
||||
@@ -585,6 +585,20 @@ const paths = {
|
||||
},
|
||||
},
|
||||
},
|
||||
"/api/lanes/{id}/git/tree-all": {
|
||||
get: {
|
||||
tags: ["Lanes"],
|
||||
summary: "Every level of the tracked tree in one read",
|
||||
description:
|
||||
"The file explorer's expand-all-folders read: ONE git ls-files, grouped into levels keyed by directory (\"\" is the root), each level shaped and capped like GET /api/lanes/{id}/git/tree's entries. Read-only, no same-origin guard.",
|
||||
operationId: "listLaneTreeAll",
|
||||
parameters: [{ name: "id", in: "path", required: true, schema: { type: "integer" } }],
|
||||
responses: {
|
||||
200: { description: "{available, levels:{<dir>:[{name, path, dir}]}, truncated}." },
|
||||
404: { description: "Lane not found." },
|
||||
},
|
||||
},
|
||||
},
|
||||
"/api/lanes/{id}/git/branches": {
|
||||
get: {
|
||||
tags: ["Lanes"],
|
||||
@@ -604,7 +618,7 @@ const paths = {
|
||||
tags: ["Lanes"],
|
||||
summary: "One git write on the lane's working copy",
|
||||
description:
|
||||
"fetch (--all --prune), pull (ALWAYS --ff-only — a diverged branch is reported, never merged), push (-u <remote> HEAD, so only the branch the lane is on; remote = the branch's upstream remote, else the only remote, else origin, else 400 ENOREMOTE), stage/unstage (per file), discard (per file; irreversible, so it REQUIRES confirm:true), commit (git add -A then commit -m <message>, or only:\"staged\" to take the index as it stands), switch (git switch, -c to create; refuses a dirty tree so an agent's half-finished work is never carried onto another branch), and branch-create / branch-delete (create never switches; delete is `git branch -d`, refuses main/master/development/develop, the current branch and one held by another worktree). A path in the body must be one `git status` is reporting as changed, so no path outside the lane is reachable. Guarded and serialized per git index (the lane lock keyed on the worktree's git dir, so two lanes sharing one index cannot collide on index.lock). Deliberately no merge, rebase, reset or stash: reset stays behind the destroy guard on POST /api/lanes/{id}/reset. Network actions are killed after 60s.",
|
||||
"fetch (--all --prune), pull (ALWAYS --ff-only — a diverged branch is reported, never merged), push (-u <remote> HEAD, so only the branch the lane is on; remote = the branch's upstream remote, else the only remote, else origin, else 400 ENOREMOTE), stage/unstage (per file), discard (per file; irreversible, so it REQUIRES confirm:true), stage-hunk / discard-hunk (ONE hunk of a tracked file's `git diff HEAD`, named by its `@@` line and re-read server-side at the given context — the applied patch is always git's own text, never one from the request; discard-hunk REQUIRES confirm:true; 400 EUNTRACKED for an untracked file, 409 EHUNKGONE when the hunk is no longer in the diff), commit (git add -A then commit -m <message>, or only:\"staged\" to take the index as it stands), switch (git switch, -c to create; refuses a dirty tree so an agent's half-finished work is never carried onto another branch), and branch-create / branch-delete (create never switches; delete is `git branch -d`, refuses main/master/development/develop, the current branch and one held by another worktree). A path in the body must be one `git status` is reporting as changed, so no path outside the lane is reachable. Guarded and serialized per git index (the lane lock keyed on the worktree's git dir, so two lanes sharing one index cannot collide on index.lock). Deliberately no merge, rebase, reset or stash: reset stays behind the destroy guard on POST /api/lanes/{id}/reset. Network actions are killed after 60s.",
|
||||
operationId: "runLaneGitAction",
|
||||
parameters: [
|
||||
{ name: "id", in: "path", required: true, schema: { type: "integer" } },
|
||||
@@ -621,6 +635,8 @@ const paths = {
|
||||
"stage",
|
||||
"unstage",
|
||||
"discard",
|
||||
"stage-hunk",
|
||||
"discard-hunk",
|
||||
"commit",
|
||||
"switch",
|
||||
"branch-create",
|
||||
@@ -653,9 +669,23 @@ const paths = {
|
||||
items: { type: "string" },
|
||||
description: "stage, unstage, discard; each must be a path git reports changed.",
|
||||
},
|
||||
path: {
|
||||
type: "string",
|
||||
description:
|
||||
"stage-hunk, discard-hunk; a path git reports changed (not untracked).",
|
||||
},
|
||||
hunk: {
|
||||
type: "string",
|
||||
description:
|
||||
"stage-hunk, discard-hunk; the hunk's `@@` line as the diff returned it. The server re-reads the diff and applies git's own text of that hunk; a hunk no longer present is 409 EHUNKGONE.",
|
||||
},
|
||||
context: {
|
||||
type: "integer",
|
||||
description: "stage-hunk, discard-hunk; the context the hunk was read at.",
|
||||
},
|
||||
confirm: {
|
||||
type: "boolean",
|
||||
description: "discard only; the call is refused without it.",
|
||||
description: "discard and discard-hunk; the call is refused without it.",
|
||||
},
|
||||
},
|
||||
},
|
||||
|
||||
@@ -951,13 +951,19 @@ router.post("/:id/git/:action", sameOriginGuard, async (req, res) => {
|
||||
"EPROTECTED",
|
||||
"ESTAGEDOUTSIDE",
|
||||
"ENOREMOTE",
|
||||
"EUNTRACKED",
|
||||
];
|
||||
// A numeric code is git's own exit status (execFile reports one that way):
|
||||
// git ran and refused — a rejected push, a failed credential, a diverged
|
||||
// pull. That is the repository's state answering a valid request, not a
|
||||
// server fault, so it is a 409 under the string code the client expects.
|
||||
const exited = typeof err.code === "number";
|
||||
const status = badRequest.includes(err.code) ? 400 : exited ? 409 : 500;
|
||||
// EHUNKGONE is the same kind of answer: the tree moved under the click.
|
||||
const status = badRequest.includes(err.code)
|
||||
? 400
|
||||
: exited || err.code === "EHUNKGONE"
|
||||
? 409
|
||||
: 500;
|
||||
// git's own stderr is the useful half of a failed push or pull (a
|
||||
// rejection, a missing credential, a diverged branch), so it joins the
|
||||
// message rather than riding a side field the client would have to know
|
||||
|
||||
Reference in New Issue
Block a user