@tablation/crew 0.85.0 → 0.86.0

package/dist/cli.js

@@ -6905,6 +6905,33 @@ var Tracker = class {
     const { shipId } = await this.authorshipProbe();
     return this.client.records.create(modelId, { ...fields, ...shipId ? { ship_id: shipId } : {} });
   }
+  /**
+   * This ship's Periscopes rows (EPIC-077), newest first, with the ticket each
+   * belongs to. Empty when there is no Periscopes table or no Ships row yet.
+   */
+  async periscopeRows(states) {
+    const modelId = this.route.resolved?.periscopesModelId;
+    const { shipId } = await this.authorshipProbe();
+    if (!modelId || !shipId) return [];
+    const conds = [{ columnName: "ship_id", operator: "EQ", value: shipId }];
+    if (states?.length) conds.push({ columnName: "state", operator: "IN", value: states });
+    const rows = await this.client.records.list(modelId, { filters: encodeFilters(conds), limit: 200 });
+    const refId = (v) => typeof v === "string" ? v : v && typeof v === "object" && typeof v.id === "string" ? v.id : void 0;
+    const ids = [...new Set(rows.map((r) => refId(r.issue_id)).filter((x) => !!x))];
+    const tickets = new Map((await this.ticketsByIds(ids)).map((t) => [t.id, t]));
+    const out = [];
+    for (const row of rows) {
+      const t = tickets.get(refId(row.issue_id) ?? "");
+      if (t) out.push({ row, ticket: t });
+    }
+    return out.sort((a, b) => String(b.row.started_at ?? "").localeCompare(String(a.row.started_at ?? "")));
+  }
+  /** Updates one Periscopes row (EPIC-077). */
+  async updatePeriscope(id, patch2) {
+    const modelId = this.route.resolved?.periscopesModelId;
+    if (!modelId) throw new Error("this workspace has no Periscopes table");
+    await this.client.records.update(modelId, id, patch2);
+  }
   /**
    * The authorship columns this workspace is missing, as `table.column` names
    * for `crew doctor` to report (CREW-1371). Empty on a fully updated install.
@@ -16532,6 +16559,109 @@ ${tail(preview.output)}`);
   });
   return { ticket: draft.tag, ticketRecordId: draft.id, worktree: wt.path, branch: wt.branch, url, periscopeRecordId: row.id };
 }
+function parsePeriscopeDownArgs(positional2, flags) {
+  const usage2 = "usage: crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]";
+  const rest = positional2.slice(2);
+  if (rest.length === 0 || rest.length > 2) throw new PeriscopeError(usage2);
+  if (flags.keep === flags.discard) throw new PeriscopeError(`pass exactly one of --keep or --discard
+${usage2}`);
+  const m = /^(?:[A-Za-z]+-)?(\d+)$/.exec(rest[rest.length - 1]);
+  if (!m) throw new PeriscopeError(`"${rest[rest.length - 1]}" is not a ticket number
+${usage2}`);
+  return {
+    ...rest.length === 2 ? { route: rest[0] } : {},
+    number: m[1],
+    mode: flags.keep ? "keep" : "discard",
+    allowEmpty: flags.allowEmpty,
+    json: flags.json
+  };
+}
+var PROTOTYPE_HEADING = "## Prototype";
+function prototypeSection(files) {
+  const added = files.reduce((n, f) => n + f.added, 0);
+  const removed = files.reduce((n, f) => n + f.removed, 0);
+  return [
+    PROTOTYPE_HEADING,
+    "",
+    "This branch began as a Periscope prototype and may be rewritten rather than treated as reviewed work.",
+    "",
+    ...files.length === 0 ? ["No files differ from the base."] : files.map((f) => `- \`${f.path}\` (+${f.added} \u2212${f.removed})`),
+    "",
+    `${files.length} file${files.length === 1 ? "" : "s"} changed, ${added} insertion${added === 1 ? "" : "s"}(+), ${removed} deletion${removed === 1 ? "" : "s"}(\u2212)`
+  ].join("\n");
+}
+async function runPeriscopeDown(d, args) {
+  const rows = await d.rowsForTicket(args.number);
+  if (rows.length === 0) throw new PeriscopeError(`no periscope for ticket ${args.number} on this ship`);
+  const row = rows.find((r) => r.state === "live");
+  if (!row) {
+    const done = rows[0];
+    d.say("unchanged", `${done.ticket} is already ${done.state}; nothing to do`);
+    return { ticket: done.ticket, mode: args.mode, outcome: "unchanged", state: done.state };
+  }
+  if (args.mode === "discard") {
+    const killed2 = await d.stopServer(row.worktree, row.number);
+    d.say("server", killed2 ? `stopped ${killed2} process(es)` : "no server was listening");
+    d.removeWorktree(row.worktree, row.branch, true);
+    d.say("worktree", `removed ${row.worktree} and branch ${row.branch}`);
+    await d.updateTicket(row.ticketRecordId, {
+      status: "discarded",
+      fillProjectAndRepo: false,
+      note: "The periscope was discarded; nothing was pushed."
+    });
+    d.say("ticket", `${row.ticket} closed as obsolete`);
+    await d.setRowState(row.id, "discarded");
+    d.say("row", "row is discarded");
+    return { ticket: row.ticket, mode: "discard", outcome: "done", state: "discarded" };
+  }
+  const dirty = d.hasChanges(row.worktree);
+  if (!dirty && !args.allowEmpty) {
+    throw new PeriscopeError(`${row.ticket} has nothing to commit; pass --allow-empty to keep the branch anyway, or --discard`);
+  }
+  if (dirty) {
+    d.commitAll(row.worktree, `${row.ticket} Periscope prototype`);
+    d.say("commit", `committed the worktree on ${row.branch}`);
+  }
+  const pushed = d.push(row.worktree, row.branch);
+  d.say("push", `pushed ${pushed.sha} to ${pushed.remote}/${row.branch}`, { sha: pushed.sha });
+  const t = await d.readTicket(row.ticketRecordId);
+  const section = prototypeSection(d.changedFiles(row.worktree));
+  const description = t.description.includes(PROTOTYPE_HEADING) ? t.description : `${t.description.trimEnd()}
+
+${section}`;
+  await d.updateTicket(row.ticketRecordId, {
+    description,
+    fillProjectAndRepo: !t.hasProject || !t.hasRepo,
+    status: "new"
+  });
+  d.say("ticket", `${row.ticket} is new and unassigned with a Prototype section`);
+  await d.postPushed(row.ticketRecordId, pushed.sha, pushed.remote, row.branch);
+  const killed = await d.stopServer(row.worktree, row.number);
+  d.say("server", killed ? `stopped ${killed} process(es)` : "no server was listening");
+  d.removeWorktree(row.worktree, row.branch, false);
+  d.say("worktree", `removed ${row.worktree}; ${row.branch} stays, pushed`);
+  await d.setRowState(row.id, "kept");
+  d.say("row", "row is kept");
+  return { ticket: row.ticket, mode: "keep", outcome: "done", state: "kept", sha: pushed.sha };
+}
+function periscopeListEntries(rows, now, isListening) {
+  return rows.filter((r) => r.state === "live").map((r) => {
+    const at = r.lastActivityAt ? new Date(r.lastActivityAt).getTime() : NaN;
+    return { ...r, idleMinutes: Number.isNaN(at) ? null : Math.max(0, Math.floor((now.getTime() - at) / 6e4)), listening: isListening(r) };
+  });
+}
+function formatPeriscopeList(entries) {
+  if (entries.length === 0) return "no live periscopes on this ship";
+  return entries.map((e) => [
+    e.ticket,
+    e.repo,
+    e.worktree,
+    e.url,
+    e.state,
+    e.idleMinutes === null ? "idle ?" : `idle ${e.idleMinutes} min`,
+    e.listening ? "listening" : "not listening"
+  ].join("  ")).join("\n");
+}
 
 // src/cli.ts
 import { dirname as dirOf, resolve as resolvePath } from "path";
@@ -17996,6 +18126,9 @@ function usage(problem, requested = false) {
   crew rotate-passenger-url [route]   force a Host Passengers tunnel to reconnect with a fresh public URL
   crew periscope up [route] REPO --topic TEXT [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]
                                  file a draft ticket, cut and prepare its worktree, start the repo's preview hook and record a Periscopes row (alias: start)
+  crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]
+                                 end a periscope: commit and push its branch (ticket back to new), or throw it away (alias: end)
+  crew periscope list [route] [--json]   the live periscopes on this ship, their idle minutes and whether each server is listening
   crew worktree [route] NNN      cut (or refresh) this run's worktree for a ticket from the remote; prints its path
   crew unassign [route] NNN      hand back a session's ticket \u2014 clears assignee, next cycle picks it up
   crew sync [route]              fast-forward the checkout and its worktrees from the remote
@@ -21422,14 +21555,141 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "periscope": {
       const subP = positional[1];
-      if (subP !== "up" && subP !== "start") {
+      if (subP !== "up" && subP !== "start" && subP !== "down" && subP !== "end" && subP !== "list") {
         process.stderr.write("crew periscope up [route] REPO --topic TEXT [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]\n");
+        process.stderr.write("crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]\n");
+        process.stderr.write("crew periscope list [route] [--json]\n");
         process.exit(2);
       }
       const jsonP = flag("json");
       const say = (event, message, data = {}) => process.stderr.write(jsonP ? `${JSON.stringify({ ...data, event, message })}
 ` : `${message}
 `);
+      if (subP === "down" || subP === "end" || subP === "list") {
+        try {
+          const downArgs = subP === "list" ? void 0 : parsePeriscopeDownArgs(positional, { keep: flag("keep"), discard: flag("discard"), allowEmpty: flag("allow-empty"), json: jsonP });
+          const routeName = subP === "list" ? positional[2] : downArgs.route;
+          const routesP = (routeName ? [findRoute(cfg, routeName)] : cfg.routes.filter((r) => r.enabled)).filter((r) => r.resolved?.periscopesModelId);
+          if (routesP.length === 0) throw new PeriscopeError("no connected route has a Periscopes table");
+          const gather = async (rt) => {
+            const tr = new Tracker(rt, cfg.ship);
+            const repos = await resolvedRepos(rt);
+            return (await tr.periscopeRows()).map(({ row, ticket }) => {
+              const repo = repos.find((r) => r.id && r.id === ticket[tr.contract.columns.repo]) ?? (repos.length === 1 ? repos[0] : void 0);
+              const str = (v) => typeof v === "string" ? v : "";
+              return {
+                id: row.id,
+                ticketRecordId: ticket.id,
+                ticket: ticket.issue_tag ?? ticket.issue_id,
+                number: /(\d+)$/.exec(ticket.issue_id)?.[1] ?? "",
+                repo: repo?.name ?? "?",
+                state: str(row.state),
+                url: str(row.url),
+                worktree: str(row.worktree),
+                branch: str(row.branch),
+                lastActivityAt: str(row.last_activity_at) || null
+              };
+            });
+          };
+          if (subP === "list") {
+            const entries = periscopeListEntries(
+              (await Promise.all(routesP.map(gather))).flat(),
+              /* @__PURE__ */ new Date(),
+              (r) => pidsInWorktree(r.worktree, Number(r.number)).length > 0
+            );
+            process.stdout.write(jsonP ? `${JSON.stringify(entries)}
+` : `${formatPeriscopeList(entries)}
+`);
+            break;
+          }
+          const a = downArgs;
+          const hits = [];
+          for (const rt of routesP) {
+            const rows = (await gather(rt)).filter((r) => r.number === a.number);
+            if (rows.length) hits.push({ rt, rows });
+          }
+          if (hits.length !== 1) {
+            throw new PeriscopeError(hits.length === 0 ? `no periscope for ticket ${a.number} on this ship` : `ticket ${a.number} has periscopes on more than one route (${hits.map((h) => h.rt.route).join(", ")}) \u2014 name the route`);
+          }
+          const { rt: routeD, rows: rowsD } = hits[0];
+          const trD = new Tracker(routeD, cfg.ship);
+          const cD = trD.contract;
+          const reposD = await resolvedRepos(routeD);
+          const repoD = reposD.find((r) => r.name === rowsD[0].repo);
+          if (!repoD) throw new PeriscopeError(`cannot tell which repository ${rowsD[0].ticket} belongs to`);
+          const { remote, base } = repoD.config.branch;
+          const memberD = routeD.resolved.seats.pair ?? routeD.resolved.operator;
+          const closedD = cD.statuses.resolved.includes("closed_obsolete") ? "closed_obsolete" : cD.statuses.wontFix;
+          const depsD = {
+            rowsForTicket: async () => rowsD,
+            hasChanges: (wt) => status(wt).length > 0,
+            commitAll: (wt, msg) => {
+              git(wt, ["add", "-A"]);
+              git(wt, ["commit", "-m", msg]);
+            },
+            push: (wt, branch) => {
+              pushBranchUpstream(wt, remote, branch);
+              return { sha: headSha(wt), remote };
+            },
+            changedFiles: (wt) => {
+              const out = gitOk(wt, ["diff", "--numstat", `${remote}/${base}...HEAD`]) ?? "";
+              return out.split("\n").filter(Boolean).map((l) => {
+                const [add, rem, ...p] = l.split("	");
+                return { path: p.join("	"), added: Number(add) || 0, removed: Number(rem) || 0 };
+              });
+            },
+            readTicket: async (id) => {
+              const t = await trD.ticket(id);
+              return { description: String(t.description ?? ""), hasProject: !!t[cD.columns.slice], hasRepo: !!t[cD.columns.repo] };
+            },
+            updateTicket: async (id, p) => {
+              const patch2 = {};
+              if (p.status === "new") {
+                patch2[cD.columns.status] = "new";
+                patch2[cD.columns.assignee] = null;
+                if (p.description !== void 0) patch2.description = p.description;
+                if (p.fillProjectAndRepo) {
+                  if (routeD.resolved.areaId) patch2[cD.columns.slice] = routeD.resolved.areaId;
+                  if (repoD.id) patch2[cD.columns.repo] = repoD.id;
+                }
+              } else {
+                patch2[cD.columns.status] = closedD;
+                patch2[cD.columns.resolutionNote] = p.note;
+              }
+              await trD.updateTicket(id, patch2);
+            },
+            postPushed: (id, sha, rem, branch) => trD.postEvent(id, pushedEventBody(sha, rem, branch), memberD, "pushed"),
+            stopServer: async (wt, n) => {
+              const pids = pidsInWorktree(wt, Number(n));
+              if (pids.length) await killGently(pids);
+              return pids.length;
+            },
+            removeWorktree: (wt, branch, deleteBranch) => {
+              gitOk(repoD.dir, ["worktree", "remove", "--force", wt]);
+              if (deleteBranch) gitOk(repoD.dir, ["branch", "-D", branch]);
+            },
+            setRowState: (id, state2) => trD.updatePeriscope(id, { state: state2 }),
+            say
+          };
+          if (dryRun) {
+            say("dry-run", `would end the periscope for ${rowsD[0].ticket} (${a.mode})`);
+            break;
+          }
+          const res = await runPeriscopeDown(depsD, a);
+          if (jsonP) process.stdout.write(`${JSON.stringify({ event: "done", ...res })}
+`);
+          else process.stdout.write(`${res.ticket} ${res.state}
+`);
+        } catch (e) {
+          if (e instanceof PeriscopeError || e instanceof ConfigError) {
+            process.stderr.write(`crew periscope: ${e.message}
+`);
+            process.exit(1);
+          }
+          throw e;
+        }
+        break;
+      }
       try {
         const a = parsePeriscopeUpArgs(positional, { topic: value("topic"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
         const candidatesP = a.route ? [findRoute(cfg, a.route)] : cfg.routes.filter((r) => r.enabled);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",