@shiyuphan/follow-me 0.5.0 → 0.6.0

package/dist/src/git.js

@@ -1,13 +1,16 @@
 import { execFile } from "node:child_process";
 import { link, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { isSha, neededBlobs, parseDiff } from "./diff.js";
+import { isRepoPath, isSha, neededBlobs, parseDiff } from "./diff.js";
 export class GitError extends Error {
     name = "GitError";
     args;
-    constructor(args, stderr) {
+    /** git's exit status, or null when it did not run or was killed. */
+    status;
+    constructor(args, stderr, status = null) {
         super(`git ${args.join(" ")}: ${stderr}`);
         this.args = args;
+        this.status = status;
     }
 }
 function git(repo, args, opts = {}) {
@@ -18,8 +21,10 @@ function git(repo, args, opts = {}) {
             maxBuffer: 1 << 30,
             env: { ...process.env, ...opts.env },
         }, (error, stdout, stderr) => {
-            if (error)
-                reject(new GitError(args, stderr.toString("utf8").trim() || error.message));
+            if (error) {
+                const status = typeof error.code === "number" ? error.code : null;
+                reject(new GitError(args, stderr.toString("utf8").trim() || error.message, status));
+            }
             else
                 resolve(stdout);
         });
@@ -97,25 +102,76 @@ export async function defaultBaseRef(repo) {
     }
     throw new Error("neither main nor master exists; pass --base <ref>");
 }
-async function catBlobs(repo, shas) {
-    const blobs = new Map();
-    if (shas.length === 0)
-        return blobs;
-    const out = await git(repo, ["cat-file", "--batch"], { input: `${shas.join("\n")}\n` });
+/** The blob named by each object spec, in order, as latin1; throws when one is not a blob. */
+async function catBatch(repo, specs) {
+    if (specs.length === 0)
+        return [];
+    const input = Buffer.from(`${specs.join("\n")}\n`, "latin1");
+    const out = await git(repo, ["cat-file", "--batch"], { input });
+    const blobs = [];
     let at = 0;
-    for (const sha of shas) {
+    for (const spec of specs) {
         const nl = out.indexOf(0x0a, at);
         const header = out.subarray(at, nl).toString("latin1");
         const m = /^([0-9a-f]+) blob (\d+)$/.exec(header);
-        if (nl === -1 || m === null || m[1] !== sha) {
-            throw new Error(`cat-file returned "${header}" for ${sha}`);
+        if (nl === -1 || m === null || (isSha(spec) && m[1] !== spec)) {
+            throw new Error(`cat-file returned "${header}" for ${spec}`);
         }
         const size = Number(m[2]);
-        blobs.set(sha, out.subarray(nl + 1, nl + 1 + size).toString("latin1"));
+        blobs.push(out.subarray(nl + 1, nl + 1 + size).toString("latin1"));
         at = nl + 1 + size + 1;
     }
     return blobs;
 }
+async function catBlobs(repo, shas) {
+    const blobs = await catBatch(repo, shas);
+    return new Map(shas.map((sha, i) => [sha, blobs[i] ?? ""]));
+}
+/** Each path's bytes at the commit, as latin1. */
+export async function blobsAt(repo, commit, paths) {
+    const blobs = await catBatch(repo, paths.map((p) => `${commit}:${p}`));
+    return new Map(paths.map((p, i) => [p, blobs[i] ?? ""]));
+}
+/**
+ * Lines of the commit's tree, not the working tree, that match any of the POSIX extended
+ * patterns, in files matching the pathspecs. Binary files are skipped.
+ */
+export async function grepTip(repo, commit, patterns, pathspecs) {
+    const args = [
+        "grep",
+        "-n",
+        "-E",
+        "-I",
+        "-z",
+        "--no-color",
+        "--no-column",
+        ...patterns.flatMap((p) => ["-e", p]),
+        commit,
+        "--",
+        ...pathspecs,
+    ];
+    let out;
+    try {
+        out = await git(repo, args);
+    }
+    catch (error) {
+        // grep exits 1 when nothing matched.
+        if (error instanceof GitError && error.status === 1)
+            return [];
+        throw error;
+    }
+    const prefix = `${commit}:`;
+    return out
+        .toString("latin1")
+        .split("\n")
+        .flatMap((record) => {
+        const [name = "", line = "", ...text] = record.split("\0");
+        const path = name.slice(prefix.length);
+        if (!name.startsWith(prefix) || !isRepoPath(path) || !/^\d+$/.test(line))
+            return [];
+        return [{ path, line: Number(line), text: text.join("\0") }];
+    });
+}
 const DIFF_FLAGS = ["--no-renames", "--full-index", "--no-color", "--no-ext-diff", "--no-textconv"];
 export async function loadDiff(repo, baseRef, tipRef) {
     const [tip, baseCommit] = await Promise.all([

package/dist/src/host.js

@@ -6,8 +6,8 @@ import { join } from "node:path";
 import { parseCarried, parseComment, parseEvent, parseEventBatch, } from "./comments.js";
 import { carryComments } from "./evolve.js";
 import { isPlanVersion, serializePlanFile, validatePlan } from "./plan.js";
-import { HEALTH_APP, isSessionId, loadDraftComments, PortInUseError, RegistrationError, startServer, } from "./server.js";
-import { BranchMovedError, diffOfPlan, isAlive, openSessionAt, SessionFileError, SessionLockedError, } from "./session.js";
+import { HEALTH_APP, isSessionId, loadDraft, PortInUseError, RegistrationError, startServer, } from "./server.js";
+import { BranchMovedError, diffOfPlan, isAlive, openSessionAt, SessionFileError, SessionLockedError, sessionComments, } from "./session.js";
 const RECORD = "server.json";
 const DEFAULT_IDLE_MS = 30_000;
 const START_TIMEOUT_MS = 10_000;
@@ -127,7 +127,15 @@ async function loadHosted(registration, held) {
             throw new RegistrationError(`plan v${version} no longer fits ${branch}; check it again`);
         }
         const reviewsDir = session.reviewsDir();
-        const comments = await loadDraftComments(reviewsDir, version);
+        const draft = await loadDraft(reviewsDir, version);
+        const { comments } = draft;
+        // A restart in the middle of a review that swapped: the draft names what was said before.
+        const earlier = draft.carried === null
+            ? null
+            : {
+                comments: sessionComments(draft.carried, reviewed.filter((r) => r.version < version).map((r) => r.review)),
+                concerns: draft.carriedConcerns,
+            };
         const prior = session.priorReview(mode, version);
         const previous = prior === null || prior.comments.length === 0
             ? null
@@ -151,6 +159,7 @@ async function loadHosted(registration, held) {
             release,
             previous,
             carried,
+            earlier,
             state: {
                 mode,
                 anchor: session.anchor,

package/dist/src/plan.js

@@ -17,6 +17,10 @@ const STATUSES = ["addressed", "declined", "deferred", "answered"];
 function isResponseStatus(s) {
     return STATUSES.some((x) => x === s);
 }
+const SECTIONS = ["story", "steps", "details", "wiring"];
+function isCommitSection(s) {
+    return SECTIONS.some((x) => x === s);
+}
 const SEVERITIES = ["blocker", "major", "minor"];
 const CONCERN_KINDS = ["bug", "missing-test", "naming", "risk"];
 export function isSeverity(s) {
@@ -90,6 +94,20 @@ function parseConcern(v, onUnit) {
         return "lines: expected a list of change indices";
     return { severity, kind, text, lines: [...new Set(indices)].sort((a, b) => a - b) };
 }
+/** A concern as validation placed it, stored beside a review: with its id and its unit. */
+export function parsePlacedConcern(v) {
+    if (!isFields(v))
+        return "expected an object";
+    if (!isConcernId(v.id))
+        return "id: expected a concern id";
+    if (v.unit !== undefined && !(typeof v.unit === "string" && isUnitId(v.unit))) {
+        return "unit: expected a unit id";
+    }
+    const concern = parseConcern(v, v.unit !== undefined);
+    if (typeof concern === "string")
+        return concern;
+    return { ...concern, id: v.id, ...(v.unit === undefined ? {} : { unit: v.unit }) };
+}
 /** Absent, null and [] all mean no concerns, so a planner may always write the field. */
 function parseConcerns(v, onUnit) {
     if (v === undefined || v === null)
@@ -209,6 +227,10 @@ export function parsePlanFile(draft) {
             }
             if (typeof c.message !== "string")
                 bad(`${at}.message`, "expected a string");
+            const section = c.section ?? null;
+            if (section !== null && !isCommitSection(section)) {
+                bad(`${at}.section`, `expected one of ${SECTIONS.join(", ")}`);
+            }
             const extras = parseExtras(c, false);
             if ("error" in extras)
                 bad(`${at}.${extras.field}`, extras.error);
@@ -225,7 +247,8 @@ export function parsePlanFile(draft) {
                 }
             }
             if (typeof c.message === "string" && !("error" in extras)) {
-                commits.push({ message: c.message, ...extras, units });
+                const placed = isCommitSection(section) ? { section } : {};
+                commits.push({ message: c.message, ...placed, ...extras, units });
             }
         }
     }
@@ -273,6 +296,7 @@ export function serializePlanFile(file) {
         tip: file.tip,
         commits: file.commits.map((c) => ({
             message: c.message,
+            ...(c.section === undefined ? {} : { section: c.section }),
             ...serializeExtras(c),
             units: c.units.map((ref) => ref.narration === undefined && ref.diagram === undefined && ref.concerns === undefined
                 ? formatUnitRef(ref)
@@ -564,6 +588,7 @@ function project(diff, file, claims, issues) {
         return {
             index: k,
             message: commit.message,
+            ...(commit.section === undefined ? {} : { section: commit.section }),
             ...withText(commit.narration ?? null, commit.diagram ?? null),
             ...(mine.length === 0 ? {} : { concerns: mine }),
             refs,

package/dist/src/prompt.js

@@ -1,4 +1,5 @@
 import { tipStartOf } from "./diff.js";
+import { anchorOn, concernOn } from "./evolve.js";
 /** Consecutive runs collapse: [0,1,2,3,7] becomes "0-3,7". */
 function formatRanges(changes) {
     const sorted = [...new Set(changes)].sort((a, b) => a - b);
@@ -383,10 +384,23 @@ function quoteHunk(units, commits, unit, k, picked) {
     return { line, text: lines.map((l) => l.text) };
 }
 const SEVERITY_RANK = { blocker: 0, major: 1, minor: 2 };
+/** Marks the label of what was said before its code changed, and places what lost its code. */
+function marked(ctx, id, where, quote) {
+    const mark = ctx.marks?.get(id);
+    if (mark === undefined)
+        return where;
+    if (mark.gone) {
+        return { path: mark.path, line: null, label: `the code is gone after v${mark.since}`, quote };
+    }
+    return { ...where, label: `${where.label} · the code changed after v${mark.since}` };
+}
 function lineLabel(line, fallback) {
     return line === null ? fallback : `line ${line}`;
 }
 function whereComment(ctx, c) {
+    return marked(ctx, c.id, whereOnTip(ctx, c), c.context.lines ?? []);
+}
+function whereOnTip(ctx, c) {
     const { anchor } = c;
     switch (anchor.kind) {
         case "plan":
@@ -429,6 +443,9 @@ function whereComment(ctx, c) {
     }
 }
 function whereConcern(ctx, kept) {
+    return marked(ctx, kept.concern.id, concernOnTip(ctx, kept), []);
+}
+function concernOnTip(ctx, kept) {
     const { concern, commit } = kept;
     if (concern.unit === undefined) {
         return { path: null, line: null, label: `commit ${commit + 1}`, quote: [] };
@@ -727,8 +744,12 @@ function threadOf(c) {
 function withSeverity(severity, text) {
     return severity === null ? text : `**${severity}**\n\n${text}`;
 }
-function collectItems(review, commits, units, responses) {
-    const ctx = { commits, units };
+function changedOf(ctx, id) {
+    const mark = ctx.marks?.get(id);
+    return mark === undefined ? {} : { changed: { since: mark.since, gone: mark.gone } };
+}
+function collectItems(review, ctx, responses) {
+    const { commits, units } = ctx;
     const fromReviewer = review.comments.filter((c) => c.author !== "agent");
     const walk = review.mode === "walk";
     const rest = fromReviewer.filter((c) => c.kind !== "question");
@@ -748,6 +769,7 @@ function collectItems(review, commits, units, responses) {
             return {
                 where: it.where,
                 item: {
+                    id: kept.concern.id,
                     ...concernSpan(ctx, kept.concern),
                     path: it.where.path,
                     oldPath: it.where.path,
@@ -757,6 +779,7 @@ function collectItems(review, commits, units, responses) {
                     thread,
                     resolved: false,
                     excluded: noConcerns.has(kept.concern.id),
+                    ...changedOf(ctx, kept.concern.id),
                 },
             };
         }
@@ -765,6 +788,7 @@ function collectItems(review, commits, units, responses) {
         return {
             where: it.where,
             item: {
+                id: first.id,
                 ...commentSpan(ctx, first),
                 path: it.where.path,
                 oldPath: it.where.path,
@@ -774,6 +798,7 @@ function collectItems(review, commits, units, responses) {
                 thread: threadOf(first),
                 resolved: resolved.has(first.id),
                 excluded: noComments.has(first.id),
+                ...changedOf(ctx, first.id),
             },
         };
     });
@@ -786,6 +811,7 @@ function collectItems(review, commits, units, responses) {
         out.push({
             where,
             item: {
+                id: q.id,
                 ...commentSpan(ctx, q),
                 path: where.path,
                 oldPath: where.path,
@@ -795,6 +821,7 @@ function collectItems(review, commits, units, responses) {
                 thread: threadOf(q),
                 resolved: resolved.has(q.id),
                 excluded: noComments.has(q.id),
+                ...changedOf(ctx, q.id),
             },
         });
     }
@@ -805,7 +832,8 @@ function collectItems(review, commits, units, responses) {
  * Excluded ones are present and marked; whoever posts them skips those.
  */
 export function reportItems(review, commits, units, opts) {
-    return collectItems(review, commits, units, opts.responses).map((c) => c.item);
+    const session = folded(review, commits, units, opts.earlier);
+    return collectItems(session.review, session.ctx, opts.responses).map((c) => c.item);
 }
 /** A short list of what the reviewer left out, so nothing vanishes without a trace. */
 function renderExcluded(collected) {
@@ -821,6 +849,64 @@ function renderExcluded(collected) {
     out.push("");
     return out;
 }
+/**
+ * The review of the whole session on this version's diff: the earlier versions' comments on
+ * their carried anchors, the concerns kept there that this plan lost added to the commit now
+ * taking their unit, and a mark on each whose code changed. Each id appears once; this
+ * version's own copy wins.
+ */
+function folded(review, commits, units, earlier) {
+    if (earlier === undefined)
+        return { review, ctx: { commits, units } };
+    const marks = new Map();
+    const mark = (id, at) => {
+        if (at.since !== null)
+            marks.set(id, { since: at.since, gone: at.unit === null, path: at.path });
+    };
+    const owner = (unit, fallback) => {
+        const k = commits.findIndex((c) => c.refs.some((r) => r.unit === unit));
+        return k === -1 ? Math.min(fallback, Math.max(commits.length - 1, 0)) : k;
+    };
+    const own = new Set(review.comments.map((c) => c.id));
+    const comments = earlier.comments
+        .filter((c) => !own.has(c.comment.id))
+        .map((c) => {
+        mark(c.comment.id, c);
+        const { anchor } = c.comment;
+        if (anchor.kind !== "hunk")
+            return c.comment;
+        const moved = anchorOn(c, units, owner(c.unit, anchor.commit));
+        return moved === null ? c.comment : { ...c.comment, anchor: moved };
+    });
+    const inPlan = new Set(commits.flatMap((c) => (c.concerns ?? []).map((k) => k.id)));
+    const lost = earlier.concerns.filter((c) => !inPlan.has(c.concern.id));
+    for (const c of lost)
+        mark(c.concern.id, c);
+    const decided = new Set((review.concerns ?? []).map((d) => d.concern));
+    return {
+        review: {
+            ...review,
+            comments: [...comments, ...review.comments],
+            concerns: [
+                ...lost.filter((c) => !decided.has(c.concern.id)).map((c) => c.decision),
+                ...(review.concerns ?? []),
+            ],
+        },
+        ctx: {
+            units,
+            marks,
+            commits: commits.map((commit, k) => {
+                const mine = lost.filter((c) => owner(c.unit, c.commit) === k);
+                if (mine.length === 0)
+                    return commit;
+                return {
+                    ...commit,
+                    concerns: [...(commit.concerns ?? []), ...mine.map((c) => concernOn(c, units))],
+                };
+            }),
+        },
+    };
+}
 /**
  * The consolidated report of a review, in the voices of both the reviewer and the agent: the
  * reviewer's comments and the agent's concerns the reviewer kept, grouped by file and ordered by
@@ -829,22 +915,24 @@ function renderExcluded(collected) {
  * Concerns the reviewer has not decided are left out, as are those dismissed.
  */
 export function renderReport(full, commits, units, opts) {
-    const excluded = full.excluded;
+    const session = folded(full, commits, units, opts.earlier);
+    const { ctx } = session;
+    const excluded = session.review.excluded;
     if (excluded === undefined)
-        return renderIncluded(full, commits, units, opts);
+        return renderIncluded(session.review, ctx, opts);
     const noComments = new Set(excluded.comments);
     const noConcerns = new Set(excluded.concerns);
     const review = {
-        ...full,
-        comments: full.comments.filter((c) => !noComments.has(c.id)),
-        concerns: (full.concerns ?? []).filter((d) => !noConcerns.has(d.concern)),
+        ...session.review,
+        comments: session.review.comments.filter((c) => !noComments.has(c.id)),
+        concerns: (session.review.concerns ?? []).filter((d) => !noConcerns.has(d.concern)),
     };
-    const tail = renderExcluded(collectItems(full, commits, units, opts.responses));
-    const main = renderIncluded(review, commits, units, opts);
+    const tail = renderExcluded(collectItems(session.review, ctx, opts.responses));
+    const main = renderIncluded(review, ctx, opts);
     return tail.length === 0 ? main : `${main}${main.endsWith("\n") ? "" : "\n"}${tail.join("\n")}`;
 }
-function renderIncluded(review, commits, units, opts) {
-    const ctx = { commits, units };
+function renderIncluded(review, ctx, opts) {
+    const { commits, units } = ctx;
     const walk = review.mode === "walk";
     const fromReviewer = review.comments.filter((c) => c.author !== "agent");
     // A thread the agent started matters to it only once the reviewer has answered.
@@ -977,3 +1065,25 @@ export function renderShownConcern(concern, commit, ctx) {
         "",
     ].join("\n");
 }
+function utf8(latin1) {
+    return Buffer.from(latin1, "latin1").toString("utf8");
+}
+/** Where a name is defined, each with the commit it lands in and its first lines at the tip. */
+export function renderShownDefinitions(name, candidates) {
+    if (candidates.length === 0)
+        return `no definition of ${name} at the tip\n`;
+    return `${candidates
+        .flatMap((c) => {
+        const where = c.commit !== null
+            ? `in commit ${c.commit + 1}`
+            : c.unit !== null
+                ? `in ${c.unit}, which no commit of the plan takes`
+                : "unchanged by the branch";
+        const width = String(c.newLine + c.preview.length - 1).length;
+        return [
+            `${utf8(c.path)}:${c.newLine} ${c.kind}, ${where}`,
+            ...c.preview.map((l, i) => `    ${String(c.newLine + i).padStart(width)}  ${utf8(l)}`),
+        ];
+    })
+        .join("\n")}\n`;
+}