@shiyuphan/follow-me 0.2.0 → 0.3.0

package/dist/src/comments.js

@@ -14,8 +14,9 @@ function isIndex(v) {
     return typeof v === "number" && Number.isInteger(v) && v >= 0;
 }
 function parseAnchor(v) {
-    if (!isFields(v))
+    if (!isFields(v)) {
         return "anchor is not an object";
+    }
     if (v.kind === "plan")
         return { kind: "plan" };
     if (!isIndex(v.commit))
@@ -27,12 +28,25 @@ function parseAnchor(v) {
         return "anchor.kind is unknown";
     if (typeof v.unit !== "string" || !isUnitId(v.unit))
         return "anchor.unit is not a unit id";
-    if (v.changes === null)
+    if (v.changes === null) {
+        if (v.offsets !== undefined)
+            return "anchor.offsets needs anchor.changes to be a list";
         return { kind: "hunk", unit: v.unit, commit, changes: null };
+    }
     if (!isArray(v.changes) || !v.changes.every(isIndex)) {
         return "anchor.changes is not null or a list of change indices";
     }
-    return { kind: "hunk", unit: v.unit, commit, changes: v.changes.filter(isIndex) };
+    const changes = v.changes.filter(isIndex);
+    if (v.offsets === undefined)
+        return { kind: "hunk", unit: v.unit, commit, changes };
+    if (!isArray(v.offsets) || v.offsets.length === 0 || !v.offsets.every(isIndex)) {
+        return "anchor.offsets is not a non-empty list of row indices";
+    }
+    const offsets = v.offsets.filter(isIndex);
+    if (!offsets.every((o, i) => i === 0 || o > (offsets[i - 1] ?? 0))) {
+        return "anchor.offsets is not strictly ascending";
+    }
+    return { kind: "hunk", unit: v.unit, commit, changes, offsets };
 }
 /** A stored reply. Replies a client posts go through parseNewReply, which mints id and time. */
 export function parseReply(v) {
@@ -101,6 +115,17 @@ export function parseComment(v) {
     }
     if (v.kind !== undefined && v.kind !== "question")
         return 'kind is not "question"';
+    if (v.author !== undefined && v.author !== "agent")
+        return 'author is not "agent"';
+    if (v.diagram !== undefined) {
+        if (typeof v.diagram !== "string")
+            return "diagram is not a string";
+        if (v.author !== "agent")
+            return "diagram is only for an agent's comment";
+        const problem = diagramProblem(v.diagram);
+        if (problem !== null)
+            return `diagram: ${problem}`;
+    }
     const follows = v.follows;
     if (follows !== undefined && !(typeof follows === "string" && isCommentId(follows))) {
         return "follows is not a comment id";
@@ -108,6 +133,11 @@ export function parseComment(v) {
     const severity = v.severity;
     if (severity !== undefined && !isSeverity(severity))
         return "severity is unknown";
+    if (v.pending !== undefined && v.pending !== true)
+        return "pending is not true";
+    if (v.pending === true && (v.kind === "question" || v.author === "agent")) {
+        return "only a reviewer's flag can be pending";
+    }
     const replies = parseList(v.replies, parseReply, "replies");
     if (typeof replies === "string")
         return replies;
@@ -124,7 +154,10 @@ export function parseComment(v) {
         ...(v.kind === "question" ? { kind: "question" } : {}),
         ...(follows === undefined ? {} : { follows }),
         ...(severity === undefined ? {} : { severity }),
+        ...(v.pending === true ? { pending: true } : {}),
         ...(replies.length === 0 ? {} : { replies }),
+        ...(v.author === "agent" ? { author: "agent" } : {}),
+        ...(v.diagram === undefined ? {} : { diagram: v.diagram }),
     };
 }
 function withDecision(concern, v) {
@@ -135,11 +168,15 @@ function withDecision(concern, v) {
         return "severity is unknown";
     if (v.note !== undefined && typeof v.note !== "string")
         return "note is not a string";
+    if (v.decidedAt !== undefined && typeof v.decidedAt !== "string") {
+        return "decidedAt is not a string";
+    }
     return {
         concern,
         decision: v.decision,
         ...(v.severity === undefined ? {} : { severity: v.severity }),
         ...(v.note === undefined || v.note.trim() === "" ? {} : { note: v.note }),
+        ...(v.decidedAt === undefined ? {} : { decidedAt: v.decidedAt }),
     };
 }
 /** A stored decision. */
@@ -150,11 +187,11 @@ export function parseDecision(v) {
         return "concern is not a concern id";
     return withDecision(v.concern, v);
 }
-/** The body of POST .../concerns/<id>; the id comes from the URL. */
+/** The body of POST .../concerns/<id>; the id comes from the URL and the time is the server's. */
 export function parseNewDecision(concern, v) {
     if (!isFields(v))
         return "the decision is not an object";
-    return withDecision(concern, v);
+    return withDecision(concern, { ...v, decidedAt: undefined });
 }
 /** Absent reads as none. The first item that does not parse names its index and reason. */
 function parseList(raw, parse, what) {
@@ -171,6 +208,21 @@ function parseList(raw, parse, what) {
     }
     return out;
 }
+function parseConcernId(item) {
+    return isConcernId(item) ? item : "not a concern id";
+}
+/** Absent reads as nothing excluded. */
+export function parseExcluded(v) {
+    if (v === undefined)
+        return { comments: [], concerns: [] };
+    if (!isFields(v))
+        return "excluded is not an object";
+    const comments = parseList(v.comments, parseCommentId, "excluded.comments");
+    if (typeof comments === "string")
+        return comments;
+    const concerns = parseList(v.concerns, parseConcernId, "excluded.concerns");
+    return typeof concerns === "string" ? concerns : { comments, concerns };
+}
 function asCommentId(item) {
     return typeof item === "string" && isCommentId(item) ? item : null;
 }
@@ -203,6 +255,10 @@ export function parseReview(v) {
     const resolved = parseList(v.resolved, parseCommentId, "resolved");
     if (typeof resolved === "string")
         return resolved;
+    const excluded = parseExcluded(v.excluded);
+    if (typeof excluded === "string")
+        return excluded;
+    const anyExcluded = excluded.comments.length + excluded.concerns.length > 0;
     return {
         schema: v.schema,
         mode,
@@ -212,6 +268,7 @@ export function parseReview(v) {
         comments,
         ...(concerns.length === 0 ? {} : { concerns }),
         ...(resolved.length === 0 ? {} : { resolved }),
+        ...(anyExcluded ? { excluded } : {}),
     };
 }
 function lenient(items, parse) {
@@ -230,10 +287,12 @@ export function parseDraft(v) {
     if (!isFields(v) || !isArray(v.comments)) {
         return "not a review draft";
     }
+    const excluded = parseExcluded(v.excluded);
     return {
         comments: lenient(v.comments, parseComment),
         concerns: lenient(v.concerns, parseDecision),
         resolved: lenient(v.resolved, parseCommentId),
+        excluded: typeof excluded === "string" ? { comments: [], concerns: [] } : excluded,
     };
 }
 export function parseEvent(v) {
@@ -280,6 +339,8 @@ export function parseEvent(v) {
                 return "malformed version event";
             return { seq, type: v.type, version: v.version, hash: v.hash };
         }
+        case "submitted":
+            return { seq, type: v.type };
         case "ended":
             return typeof v.review === "string"
                 ? { seq, type: v.type, review: v.review }

package/dist/src/git.js

@@ -134,6 +134,18 @@ export async function loadDiff(repo, baseRef, tipRef) {
     const blobs = await catBlobs(repo, neededBlobs(rawZ, patchText));
     return parseDiff({ base, tip, baseTree, tipTree, rawZ, patch: patchText, blobs });
 }
+/**
+ * Whether the configured user wrote every commit of base..tip, which is how follow-me tells its
+ * author's own branch from one it is asked to review. False when no user.email is set.
+ */
+export async function isOwnWork(repo, base, tip) {
+    const me = await gitText(repo, ["config", "--default=", "user.email"]);
+    if (me === "")
+        return false;
+    const authors = await gitText(repo, ["log", "--format=%ae", `${base}..${tip}`]);
+    const emails = authors.split("\n").filter((line) => line !== "");
+    return emails.length > 0 && emails.every((email) => email === me);
+}
 export async function signing(repo, mode) {
     const configured = await gitText(repo, [
         "config",

package/dist/src/host.js

@@ -125,7 +125,7 @@ async function loadHosted(registration, held) {
         if (!verdict.ok) {
             throw new RegistrationError(`plan v${version} no longer fits ${branch}; check it again`);
         }
-        const reviewsDir = session.reviewsDir(mode);
+        const reviewsDir = session.reviewsDir();
         const comments = await loadDraftComments(reviewsDir, version);
         const prior = session.priorReview(mode, version);
         const previous = prior === null || prior.comments.length === 0
@@ -135,7 +135,7 @@ async function loadHosted(registration, held) {
                 comments: prior.comments,
                 responses: stored.file.responses,
             };
-        const command = mode === "walk" ? "walk" : "review";
+        const command = "review";
         // A version swap runs inside the server that already owns this session's lock.
         const release = held ??
             (lockToken === null ? session.lock(command) : session.adoptLock(lockToken, command)).release;
@@ -250,14 +250,16 @@ async function call(port, method, path, body) {
 function parseSummary(raw) {
     if (!isFields(raw))
         return null;
-    const { id, url, repo, branch, mode, version, comments } = raw;
+    const { id, url, repo, branch, mode, version, comments, openedAt } = raw;
     if (typeof url !== "string" || typeof repo !== "string")
         return null;
     if (typeof branch !== "string" || (mode !== "split" && mode !== "walk"))
         return null;
     if (!isSessionId(id) || !isPlanVersion(version) || typeof comments !== "number")
         return null;
-    return { id, url, repo, branch, mode, version, comments };
+    if (typeof openedAt !== "string")
+        return null;
+    return { id, url, repo, branch, mode, version, comments, openedAt };
 }
 /** Registers a session with the server on this port; the same session yields the same URL. */
 export async function registerWith(port, registration) {
@@ -275,7 +277,7 @@ export async function swapVersion(port, summary, version, hash) {
 }
 /** One long poll of the session's event log: what happened after `since`, or nothing at timeout. */
 export async function pollEvents(port, summary, since, timeoutMs) {
-    const path = `${summary.url}api/events?since=${since}&timeout=${timeoutMs}`;
+    const path = `${summary.url}api/events?since=${since}&timeout=${timeoutMs}&audience=agent`;
     const batch = parseEventBatch(await call(port, "GET", path));
     if (typeof batch === "string")
         throw new RegistrationError(`the server sent bad events: ${batch}`);
@@ -286,7 +288,7 @@ export async function pollEvents(port, summary, since, timeoutMs) {
  * the server closes the stream, which it does after the `ended` event.
  */
 export async function followEvents(port, summary, since, onEvent) {
-    const res = await fetch(`${sessionUrl(port, summary)}api/events/stream?since=${since}`);
+    const res = await fetch(`${sessionUrl(port, summary)}api/events/stream?since=${since}&audience=agent`);
     if (!res.ok || res.body === null) {
         throw new RegistrationError(`GET api/events/stream failed with ${res.status}`);
     }
@@ -317,9 +319,18 @@ export async function postReply(port, summary, commentId, reply) {
         throw new RegistrationError("the server answered without a reply id");
     return id;
 }
+/** Posts a comment the agent starts and returns its id; the server mints id and time. */
+export async function postComment(port, summary, comment) {
+    const body = await call(port, "POST", `${summary.url}api/comments`, comment);
+    const id = isFields(body) ? body["id"] : undefined;
+    if (typeof id !== "string") {
+        throw new RegistrationError("the server answered without a comment id");
+    }
+    return id;
+}
 /** The consolidated report of the hosted session as it stands. */
-export async function fetchReport(port, summary) {
-    const res = await fetch(`${sessionUrl(port, summary)}api/report`);
+export async function fetchReport(port, summary, format = "markdown") {
+    const res = await fetch(`${sessionUrl(port, summary)}api/report?format=${format}`);
     if (!res.ok)
         throw new RegistrationError(`GET api/report failed with ${res.status}`);
     return res.text();

package/dist/src/install.js

@@ -122,6 +122,27 @@ export function runInstall(options, home, repoRoot, say, skillDir = findSkillDir
         }
     });
 }
+/**
+ * Keeps the skill current in every harness found at user scope: writes what is missing or differs
+ * from the shipped copy and says so, one line per file; says nothing when all is current. A host
+ * with no harness, or a package without its skill folder, is not an error here.
+ */
+export function syncSkills(home, say, skillDir) {
+    try {
+        const dir = skillDir ?? findSkillDir();
+        const targets = { harness: undefined, all: false, project: false, dryRun: false };
+        for (const file of planSkillFiles(targets, home, home)) {
+            const line = writeSkill(dir, file, false);
+            if (line.startsWith("wrote "))
+                say(line);
+        }
+    }
+    catch (error) {
+        if (error instanceof InstallError)
+            return;
+        process.stderr.write(`follow-me: could not update the skill: ${error instanceof Error ? error.message : error}\n`);
+    }
+}
 export function runUninstall(options, home, repoRoot, say) {
     return reportingErrors(() => {
         for (const file of planSkillFiles(options, home, repoRoot)) {

package/dist/src/plan.js

@@ -645,7 +645,7 @@ export function validatePlan(diff, draft, opts = {}) {
     const warnings = review === null
         ? []
         : review.comments
-            .filter((c) => !answered.has(c.id))
+            .filter((c) => c.author !== "agent" && !answered.has(c.id))
             .map((c) => ({ kind: "unanswered", comment: c.id, review: review.planVersion }));
     file.commits.forEach((c, commit) => {
         const length = (c.message.split("\n")[0] ?? "").length;