@allocator-one/harness-cli 1.8.0 → 1.10.0

package/README.md

@@ -52,7 +52,7 @@ the browser login attributes writes to the real user.
 ## For agents
 
 `harness mcp` runs a stdio MCP server exposing every operation as a typed
-tool — issue_list, issue_show, issue_create, issue_update, issue_claim,
+tool — issue_list, issue_show, activity_list, issue_create, issue_update, issue_claim,
 issue_close, issue_comment, issue_comment_edit, issue_comment_delete,
 relation_list/create/update/delete, relation_add/rm (blocking shorthand),
 link_list/add/update/rm,
@@ -71,6 +71,12 @@ Example tool call: `issue_list` with `{"ready": true, "team": "ALL"}`
 returns the ready queue as JSON; `issue_claim` with `{"id": "IO-123"}`
 claims atomically (a conflict means someone else holds it).
 
+Read the same mixed timeline shown in an issue's Activity section with
+`harness activity IO-123`. It returns the newest 20 entries and points out
+when older entries exist; pass `--all` to follow the opaque cursors through
+the full history. `activity_list` exposes the same `id`, `limit`, and `all`
+inputs to MCP clients.
+
 Typed issue relations are available without losing the concise blocking
 workflow. `harness dep add|rm` and the `relation_add`/`relation_rm` MCP tools
 remain the blocker-first shorthand; the full surface is:
@@ -181,10 +187,15 @@ CI regenerates the types and fails on drift.
 
 ## Release
 
-Tag a version and push — the Release workflow builds and publishes to npm:
+First bump `package.json` and `package-lock.json` through a pull request. After
+that PR is squash-merged, fetch `main` and tag the merge commit — never the
+pre-merge branch tip. Pushing the tag starts the Release workflow, which builds,
+tests, and publishes to npm:
 
 ```sh
-git tag v1.0.0 && git push origin v1.0.0
+git fetch origin main
+git tag -a vX.Y.Z MERGE_COMMIT_SHA -m "Release vX.Y.Z"
+git push origin vX.Y.Z
 ```
 
 Publishing requires the `NPM_TOKEN` actions secret (an automation token for

package/dist/{chunk-NQVQNKMC.js → chunk-KKAAKRKF.js}

@@ -166,11 +166,16 @@ var Client = class {
       throw new TransportError(transportMessage(error));
     }
     if (text === "") return { data: void 0 };
+    let parsed;
     try {
-      return JSON.parse(text);
+      parsed = JSON.parse(text);
     } catch {
       throw new TransportError(`the API answered with a non-JSON body (HTTP ${response.status})`);
     }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new TransportError(`the API answered with an invalid JSON envelope (HTTP ${response.status})`);
+    }
+    return parsed;
   }
   async toHttpError(response) {
     let parsed = {};
@@ -255,6 +260,101 @@ ${indent(String(text))}
 `).join("");
   return header + fieldLines + sectionText + relationsSection(issue["relations"]) + childrenSection(issue["children"]) + commentsSection(issue["comments"]) + imagesSection(images);
 }
+function activityEntries(entries) {
+  if (entries.length === 0) return "No activity.\n";
+  return entries.map(activityEntry).join("\n");
+}
+function activityEntry(entry) {
+  switch (entry["kind"]) {
+    case "comment":
+      return activityComment(entry);
+    case "state_event":
+      return activityStateEvent(entry);
+    default:
+      throw new CommandError(`Unknown activity entry kind: ${clean(entry["kind"])}`);
+  }
+}
+function activityComment(entry) {
+  const comment2 = requiredRecord(entry["comment"], "activity comment");
+  const authorValue = comment2["author"];
+  const author = authorValue === null ? "unknown" : optionalLabel(requiredRecord(authorValue, "comment author")["name"], "unknown", "comment author name");
+  const deleted = comment2["deleted"];
+  if (typeof deleted !== "boolean") throw new CommandError("Invalid comment deleted flag.");
+  const body = activityCommentBody(comment2["body"], deleted);
+  const text = cleanMultiline(body).split("\n").map((line) => "  " + line).join("\n");
+  return `[${clean(requiredString(entry["occurred_at"], "activity occurrence time"))}] ${clean(author)} (${clean(requiredString(comment2["id"], "comment id"))}):
+${text}
+`;
+}
+function activityCommentBody(value, deleted) {
+  if (deleted) return "[deleted comment]";
+  if (value === null || value === "") return "[comment has no text]";
+  return requiredString(value, "comment body");
+}
+function activityStateEvent(entry) {
+  const actor = activityActor(requiredRecord(entry["actor"], "activity actor"));
+  const provenance = activityProvenance(requiredRecord(entry["provenance"], "activity provenance"));
+  let description;
+  switch (entry["action"]) {
+    case "created":
+      description = `${actor} created the issue in ${stateName(entry["to_state"], "created to_state")}`;
+      break;
+    case "transition":
+      description = `${actor} moved the issue from ${nullableStateName(entry["from_state"], "transition from_state")} to ${stateName(entry["to_state"], "transition to_state")}`;
+      break;
+    case "milestone":
+      description = `${actor} recorded the ${stateName(entry["to_state"], "milestone to_state")} milestone`;
+      break;
+    default:
+      throw new CommandError(`Unknown activity action: ${clean(entry["action"])}`);
+  }
+  return `[${clean(requiredString(entry["occurred_at"], "activity occurrence time"))}] ${description} \xB7 ${provenance}
+`;
+}
+function activityActor(actor) {
+  switch (actor["kind"]) {
+    case "user":
+      return optionalLabel(actor["name"], "Unknown actor", "activity actor name");
+    case "system":
+      return "System";
+    case "deleted_user":
+      return "Deleted user";
+    case "unknown":
+      return "Unknown actor";
+    default:
+      throw new CommandError(`Unknown activity actor kind: ${clean(actor["kind"])}`);
+  }
+}
+function activityProvenance(provenance) {
+  switch (provenance["kind"]) {
+    case "live":
+    case "import":
+    case "backfill":
+      return String(provenance["kind"]);
+    default:
+      throw new CommandError(`Unknown activity provenance: ${clean(provenance["kind"])}`);
+  }
+}
+function stateName(value, field2) {
+  return optionalLabel(requiredRecord(value, field2)["name"], "Unknown state", `${field2} name`);
+}
+function nullableStateName(value, field2) {
+  return value === null ? "Unknown state" : stateName(value, field2);
+}
+function optionalLabel(value, fallback, field2) {
+  if (value === null || value === "") return fallback;
+  return clean(requiredString(value, field2));
+}
+function requiredRecord(value, field2) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CommandError(`Invalid ${field2}.`);
+  }
+  return value;
+}
+function requiredString(value, field2) {
+  if (typeof value !== "string" || value === "") throw new CommandError(`Invalid ${field2}.`);
+  return value;
+}
 function stats(data) {
   const teams = data["teams"] ?? [];
   const totals = data["totals"] ?? {};
@@ -594,6 +694,61 @@ async function show(ctx, identifier, opts) {
 `).join("");
   return notice === "" ? { json: json2, human } : { json: json2, human, notice };
 }
+var ACTIVITY_MAX_LIMIT = 100;
+async function activity(ctx, identifier, opts) {
+  requireIdentifiers([identifier]);
+  let page = await activityPage(ctx, identifier, opts.limit);
+  let entries = page.entries;
+  if (opts.all === true) {
+    const pages = [page.entries];
+    const seenCursors = /* @__PURE__ */ new Set();
+    while (page.hasMore) {
+      const cursor = page.nextCursor;
+      if (seenCursors.has(cursor)) {
+        throw new CommandError("Activity response repeated a cursor.");
+      }
+      seenCursors.add(cursor);
+      page = await activityPage(ctx, identifier, opts.limit, cursor);
+      pages.push(page.entries);
+    }
+    entries = pages.reverse().flat();
+  }
+  const notice = opts.all !== true && page.hasMore ? `harness: showing the newest ${entries.length} activity entries \u2014 pass --all for older activity.
+` : void 0;
+  return { json: entries, human: activityEntries(entries), notice };
+}
+async function activityPage(ctx, identifier, limit, before) {
+  const body = await ctx.client.get(`/api/v1/issues/${identifier}/activity`, { limit, before });
+  if (!Array.isArray(body.data)) throw new CommandError("Activity response data is not an array.");
+  if (body.data.some((entry) => typeof entry !== "object" || entry === null || Array.isArray(entry))) {
+    throw new CommandError("Activity response contains a non-object entry.");
+  }
+  const meta = body.meta;
+  if (typeof meta !== "object" || meta === null) {
+    throw new CommandError("Activity response has no pagination metadata.");
+  }
+  const hasMore = meta.has_more;
+  const nextCursor = meta.next_cursor;
+  if (typeof hasMore !== "boolean") {
+    throw new CommandError("Activity response has an invalid has_more value.");
+  }
+  if (nextCursor !== null && typeof nextCursor !== "string") {
+    throw new CommandError("Activity response has an invalid next_cursor value.");
+  }
+  if (hasMore) {
+    if (nextCursor === null || nextCursor === "") {
+      throw new CommandError("Activity response says older entries exist but provides no cursor.");
+    }
+    if (body.data.length === 0) {
+      throw new CommandError("Activity response says older entries exist but contains no entries.");
+    }
+    return { entries: body.data, hasMore: true, nextCursor };
+  }
+  if (nextCursor !== null) {
+    throw new CommandError("Activity response provides a cursor when no older entries exist.");
+  }
+  return { entries: body.data, hasMore: false, nextCursor: null };
+}
 async function stats2(ctx) {
   const body = await ctx.client.get("/api/v1/stats");
   return { json: body.data, human: stats(body.data) };
@@ -992,19 +1147,19 @@ async function claimFirst(ctx, issues) {
   }
   throw new CommandError("No claimable ready issues.");
 }
-async function setState(ctx, identifier, stateName) {
+async function setState(ctx, identifier, stateName2) {
   const showBody = await ctx.client.get(`/api/v1/issues/${identifier}`);
   const teamKey = str2((showBody.data["team"] ?? {})["key"]);
   const statesBody = await ctx.client.get(
     `/api/v1/teams/${teamKey}/workflow_states`
   );
-  const wanted = stateName.toLowerCase();
+  const wanted = stateName2.toLowerCase();
   const state = statesBody.data.find(
     (candidate) => str2(candidate["name"]).toLowerCase() === wanted || str2(candidate["type"]) === wanted
   );
   if (state === void 0) {
     const names = statesBody.data.map((candidate) => str2(candidate["name"])).join(", ");
-    throw new CommandError(`No workflow state matches "${stateName}". States: ${names}`);
+    throw new CommandError(`No workflow state matches "${stateName2}". States: ${names}`);
   }
   const body = await ctx.client.put(`/api/v1/issues/${identifier}/state`, { state_id: state["id"] });
   return body.data;
@@ -1951,6 +2106,8 @@ export {
   list,
   search,
   show,
+  ACTIVITY_MAX_LIMIT,
+  activity,
   stats2 as stats,
   prime,
   version,