@sealant/mend 0.1.0 → 0.1.1

package/dist/review-model.js

@@ -0,0 +1,212 @@
+import * as path from "node:path";
+const FILETYPE_BY_EXTENSION = {
+    c: "c",
+    cc: "cpp",
+    cpp: "cpp",
+    css: "css",
+    go: "go",
+    h: "c",
+    hpp: "cpp",
+    html: "html",
+    java: "java",
+    js: "javascript",
+    json: "json",
+    jsx: "javascript",
+    md: "markdown",
+    mjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+    sh: "bash",
+    sql: "sql",
+    swift: "swift",
+    toml: "toml",
+    ts: "typescript",
+    tsx: "tsx",
+    yaml: "yaml",
+    yml: "yaml",
+    zsh: "bash",
+};
+const filetypeOf = (name) => {
+    const extension = path.extname(name).slice(1).toLowerCase();
+    return extension === "" ? undefined : (FILETYPE_BY_EXTENSION[extension] ?? extension);
+};
+const statusOf = (patch) => {
+    if (/^new file mode /m.test(patch))
+        return "added";
+    if (/^deleted file mode /m.test(patch))
+        return "deleted";
+    if (/^rename (?:from|to) /m.test(patch))
+        return "renamed";
+    return "modified";
+};
+const isLikelyGenerated = (name) => /(^|\/)(?:dist|build|generated)(?:\/|$)/i.test(name) ||
+    /(?:\.generated\.|\.min\.(?:js|css)$|(?:^|\/)(?:pnpm-lock\.yaml|package-lock\.json|yarn\.lock)$)/i.test(name);
+/** A legible terminal whitespace mode that preserves git's control prefixes. */
+export const visibleWhitespace = (patch) => patch
+    .split("\n")
+    .map((line) => {
+    const hunkContent = (line.startsWith("+") && !line.startsWith("+++")) ||
+        (line.startsWith("-") && !line.startsWith("---")) ||
+        line.startsWith(" ");
+    if (!hunkContent)
+        return line;
+    const prefix = line.slice(0, 1);
+    const content = line.slice(1).replaceAll("\t", "→····").replaceAll(" ", "·");
+    return `${prefix}${content}`;
+})
+    .join("\n");
+/**
+ * Git is the source of this wire value, so a file begins only at a column-zero
+ * `diff --git` header. A changed source line is prefixed with +/− and cannot
+ * accidentally split the patch.
+ */
+const splitFilePatches = (diff) => {
+    const starts = [...diff.matchAll(/^diff --git /gm)].map((match) => match.index);
+    return starts.map((start, index) => {
+        const end = starts[index + 1] ?? diff.length;
+        const patch = diff.slice(start, end);
+        return patch.endsWith("\n") ? patch : `${patch}\n`;
+    });
+};
+const parseRows = (patch) => {
+    const patchLines = patch.split("\n");
+    const lines = [];
+    const hunks = [];
+    let unifiedRow = 0;
+    let splitRow = 0;
+    let hunkIndex = -1;
+    let oldLine = 0;
+    let newLine = 0;
+    for (let index = 0; index < patchLines.length; index += 1) {
+        const header = patchLines[index] ?? "";
+        const hunkMatch = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(header);
+        if (hunkMatch === null)
+            continue;
+        hunkIndex += 1;
+        oldLine = Number(hunkMatch[1]);
+        newLine = Number(hunkMatch[2]);
+        hunks.push({ index: hunkIndex, header, unifiedRow, splitRow });
+        const body = [];
+        let bodyIndex = index + 1;
+        while (bodyIndex < patchLines.length) {
+            const bodyLine = patchLines[bodyIndex] ?? "";
+            if (bodyLine.startsWith("@@ "))
+                break;
+            if (bodyLine.startsWith("+") && !bodyLine.startsWith("+++")) {
+                body.push({ kind: "addition" });
+            }
+            else if (bodyLine.startsWith("-") && !bodyLine.startsWith("---")) {
+                body.push({ kind: "deletion" });
+            }
+            else if (bodyLine.startsWith(" ")) {
+                body.push({ kind: "context" });
+            }
+            bodyIndex += 1;
+        }
+        let cursor = 0;
+        while (cursor < body.length) {
+            const current = body[cursor];
+            if (current?.kind === "context") {
+                lines.push({
+                    kind: "context",
+                    oldLine,
+                    newLine,
+                    unifiedRow,
+                    splitRow,
+                    hunk: hunkIndex,
+                    commentable: true,
+                });
+                oldLine += 1;
+                newLine += 1;
+                unifiedRow += 1;
+                splitRow += 1;
+                cursor += 1;
+                continue;
+            }
+            // Git groups a replacement as a run of deletions/additions. Unified
+            // stacks every row; split aligns the Nth deletion with the Nth addition.
+            const groupStart = cursor;
+            while (cursor < body.length && body[cursor]?.kind !== "context")
+                cursor += 1;
+            const group = body.slice(groupStart, cursor);
+            let deletionOffset = 0;
+            let additionOffset = 0;
+            for (const entry of group) {
+                if (entry.kind === "deletion") {
+                    lines.push({
+                        kind: entry.kind,
+                        oldLine,
+                        newLine: null,
+                        unifiedRow,
+                        splitRow: splitRow + deletionOffset,
+                        hunk: hunkIndex,
+                        // ReviewComment persists a line number but no old/new side. Like
+                        // the web review, deletions therefore abstain instead of storing
+                        // a confidently wrong new-file anchor.
+                        commentable: false,
+                    });
+                    oldLine += 1;
+                    deletionOffset += 1;
+                }
+                else {
+                    lines.push({
+                        kind: entry.kind,
+                        oldLine: null,
+                        newLine,
+                        unifiedRow,
+                        splitRow: splitRow + additionOffset,
+                        hunk: hunkIndex,
+                        commentable: true,
+                    });
+                    newLine += 1;
+                    additionOffset += 1;
+                }
+                unifiedRow += 1;
+            }
+            splitRow += Math.max(deletionOffset, additionOffset);
+        }
+        index = bodyIndex - 1;
+    }
+    return { lines, hunks, unifiedRows: unifiedRow, splitRows: splitRow };
+};
+/** Public review seam: the API's live git diff becomes the terminal's files, hunks, and anchors. */
+export const buildReviewFiles = (diff, stats) => {
+    const patches = splitFilePatches(diff);
+    return stats.map((stat, index) => {
+        const patch = patches[index] ?? "";
+        const rows = parseRows(patch);
+        return {
+            ...stat,
+            patch,
+            filetype: filetypeOf(stat.path),
+            status: statusOf(patch),
+            binary: /^Binary files |^GIT binary patch$/m.test(patch),
+            likelyGenerated: isLikelyGenerated(stat.path),
+            ...rows,
+        };
+    });
+};
+/** The mechanically assembled draft remains editable before the API receives it. */
+export const assembleReviewInstruction = (change, comments) => {
+    const points = comments
+        .map((comment, index) => {
+        const anchor = comment.file === null
+            ? "the change as a whole"
+            : `${comment.file}${comment.line === null ? "" : `:${comment.line}${comment.endLine === null || comment.endLine === comment.line ? "" : `-${comment.endLine}`}`}`;
+        const proposal = comment.suggestion === null
+            ? ""
+            : `\n   Proposed replacement:\n${comment.suggestion
+                .split("\n")
+                .map((line) => `   ${line}`)
+                .join("\n")}`;
+        return `${index + 1}. ${anchor} — ${comment.body}${proposal}`;
+    })
+        .join("\n");
+    return `This is a follow-up on your earlier work in this worktree, responding to review feedback. The branch ${change.branch} is already checked out with your work on it: keep working there, and do not start a new branch or reset it.
+
+Review comments:
+${points}
+
+Address each point using your own judgment about how. Check your work with the repository's own build, tests, or typecheck; a check that still fails is something to report, not to force green. Report honestly what you changed and what you did not — if a point cannot or should not be done, say so plainly.`;
+};

package/dist/review-workflow.js

@@ -0,0 +1,15 @@
+import { CONTINUE_COMMANDS } from "./shared.js";
+export const reviewTargetForSession = (session, annotation, projectName) => annotation?.changeId === null || annotation?.changeId === undefined
+    ? null
+    : { session, changeId: annotation.changeId, projectName };
+export const commentRange = (start, current) => start === null
+    ? { line: current, endLine: null }
+    : { line: Math.min(start, current), endLine: Math.max(start, current) };
+/** Close the review loop without changing session identity or worktree. */
+export const deliverReview = async (api, session, instruction) => {
+    const build = CONTINUE_COMMANDS[session.harness];
+    if (build === undefined)
+        throw new Error(`Harness “${session.harness}” has no known relaunch command`);
+    await api("POST", `/sessions/${session.id}/follow-up/deliver`, {});
+    await api("POST", `/sessions/${session.id}/launch`, { argv: build(instruction) });
+};