@tablation/crew 0.89.0 → 0.90.0

package/dist/cli.js

@@ -139,6 +139,89 @@ async function periscopesForStatus(stateDir, probe = portListening) {
   }));
 }
 
+// src/shell-init.ts
+var SHELLS = ["zsh", "bash", "fish"];
+function shellFor(requested, envShell) {
+  const pick = (requested ?? envShell ?? "").split("/").pop() ?? "";
+  return SHELLS.includes(pick) ? pick : "zsh";
+}
+var POSIX = String.raw`# crew shell-init: "periscope up" lands in the worktree, "periscope down" returns to the checkout.
+periscope() {
+  case "${"$"}{1-}" in
+    up|start)
+      shift
+      local _out _wt _url _noopen=
+      _out=$(mktemp) || return 1
+      case " $* " in *" --no-open "*) _noopen=1 ;; esac
+      command crew periscope up --json "$@" 2>&1 >"$_out" \
+        | command sed -e 's/^{.*"message":"\([^"]*\)".*}$/  \1/' >&2
+      if command grep -q '"event":"done"' "$_out"; then
+        _wt=$(command sed -n 's/.*"worktree":"\([^"]*\)".*/\1/p' "$_out" | command tail -n 1)
+        _url=$(command sed -n 's/.*"url":"\([^"]*\)".*/\1/p' "$_out" | command tail -n 1)
+      fi
+      command rm -f "$_out"
+      [ -n "$_wt" ] && [ -d "$_wt" ] || return 1
+      builtin cd "$_wt" || return 1
+      printf '%s\n%s\n' "$_url" "$_wt"
+      if [ -z "$_noopen" ] && [ -n "$_url" ]; then
+        if command -v open >/dev/null 2>&1; then command open "$_url"
+        elif command -v xdg-open >/dev/null 2>&1; then command xdg-open "$_url" >/dev/null 2>&1; fi
+      fi
+      ;;
+    down|end)
+      local _common _checkout=
+      _common=$(command git rev-parse --path-format=absolute --git-common-dir 2>/dev/null) && _checkout=${"$"}{_common%/.git}
+      command crew periscope "$@" || return $?
+      if [ -n "$_checkout" ] && [ -d "$_checkout" ]; then builtin cd "$_checkout" || return 1; fi
+      ;;
+    *)
+      command crew periscope "$@"
+      ;;
+  esac
+}
+`;
+var FISH = String.raw`# crew shell-init: "periscope up" lands in the worktree, "periscope down" returns to the checkout.
+function periscope
+    switch "$argv[1]"
+        case up start
+            set -e argv[1]
+            set -l out (mktemp); or return 1
+            command crew periscope up --json $argv 2>&1 >$out \
+                | command sed -e 's/^{.*"message":"\([^"]*\)".*}$/  \1/' >&2
+            set -l wt
+            set -l url
+            if command grep -q '"event":"done"' $out
+                set wt (command sed -n 's/.*"worktree":"\([^"]*\)".*/\1/p' $out | command tail -n 1)
+                set url (command sed -n 's/.*"url":"\([^"]*\)".*/\1/p' $out | command tail -n 1)
+            end
+            command rm -f $out
+            test -n "$wt" -a -d "$wt"; or return 1
+            builtin cd $wt; or return 1
+            printf '%s\n%s\n' $url $wt
+            if not contains -- --no-open $argv; and test -n "$url"
+                if command -sq open
+                    command open $url
+                else if command -sq xdg-open
+                    command xdg-open $url >/dev/null 2>&1
+                end
+            end
+        case down end
+            set -l checkout
+            set -l common (command git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)
+            and set checkout (string replace -r '/\.git$' '' -- $common)
+            command crew periscope $argv; or return $status
+            if test -n "$checkout" -a -d "$checkout"
+                builtin cd $checkout
+            end
+        case '*'
+            command crew periscope $argv
+    end
+end
+`;
+function shellInitScript(shell) {
+  return shell === "fish" ? FISH : POSIX;
+}
+
 // src/config.ts
 import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
 import { resolve, dirname as dirname3, isAbsolute, join as join10, basename as basename3 } from "path";
@@ -2778,12 +2861,25 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
   return result;
 }
 function routeForDir(cfg, dir) {
-  const target = resolve(dir);
-  const isInside = (base) => {
+  return locateDir(cfg, dir)?.route;
+}
+function locateDir(cfg, dir, commonDirOf) {
+  const within = (base, target2) => {
     const b = resolve(base);
-    return target === b || target.startsWith(`${b}/`);
+    return target2 === b || target2.startsWith(`${b}/`);
+  };
+  const find = (target2) => {
+    for (const route of cfg.routes) {
+      const repo = reposOf(route).find((x) => within(x.dir, target2));
+      if (repo) return { route, repo, checkout: resolve(repo.dir) };
+    }
+    return void 0;
   };
-  return cfg.routes.find((r) => reposOf(r).some((repo) => isInside(repo.dir)));
+  const target = resolve(dir);
+  const direct = find(target);
+  if (direct) return direct;
+  const common = commonDirOf?.(target);
+  return common ? find(dirname3(resolve(target, common))) : void 0;
 }
 function findRoute(cfg, route) {
   if (!route) {
@@ -9844,6 +9940,7 @@ var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "topic",
   "assignee",
   "issue",
+  "shell",
   "resume"
 ]);
 function positionalArgs(argv2) {
@@ -16564,9 +16661,9 @@ function readPeriscopePrior(stateDir, ticketRecordId) {
 var DEFAULT_MAX_PERISCOPES2 = 3;
 var DEFAULT_PERISCOPE_IDLE_MINUTES2 = 120;
 function parsePeriscopeUpArgs(positional2, flags) {
-  const usage2 = "usage: crew periscope up [route] REPO [--topic TEXT | --issue NNN] [--isolate] [--host HOST] [--assignee CREW_ROW_ID] [--json]";
+  const usage2 = "usage: crew periscope up [[route] REPO] [--topic TEXT | --issue NNN] [--isolate] [--host HOST] [--assignee CREW_ROW_ID] [--no-open] [--json]";
   const rest = positional2.slice(2);
-  if (rest.length === 0 || rest.length > 2) throw new PeriscopeError(usage2);
+  if (rest.length > 2) throw new PeriscopeError(usage2);
   const topic = flags.topic?.trim();
   let issue;
   if (flags.issue !== void 0) {
@@ -16579,7 +16676,7 @@ ${usage2}`);
   }
   return {
     ...rest.length === 2 ? { route: rest[0] } : {},
-    repo: rest[rest.length - 1],
+    ...rest.length > 0 ? { repo: rest[rest.length - 1] } : {},
     ...topic ? { topic } : {},
     ...issue ? { issue } : {},
     isolate: flags.isolate,
@@ -16618,6 +16715,25 @@ async function existingRefusal(e, t) {
   return void 0;
 }
 var tail = (s, n = 20) => s.trimEnd().split("\n").slice(-n).join("\n");
+function defaultTopic(repo, now) {
+  return `${repo}, ${now.toISOString().slice(0, 10)}`;
+}
+function openerFor(platform2) {
+  return platform2 === "darwin" ? "open" : platform2 === "linux" ? "xdg-open" : void 0;
+}
+function upOutput(res, terminal) {
+  return terminal ? `${res.ticket}
+${res.url}
+${res.worktree}
+` : `${res.ticket}
+${res.worktree}
+${res.url}
+`;
+}
+function shouldOpen(f) {
+  if (f.noOpen || f.json) return false;
+  return f.open || f.terminal;
+}
 function progressComment(url, handoff) {
   return [
     `Periscope is up: ${url}`,
@@ -16654,8 +16770,7 @@ async function runPeriscopeUp(d, args) {
     draft = prior;
     d.say("held", `holding ${prior.tag} (status ${prior.status} stays)`, { ticket: prior.tag, ticketRecordId: prior.id });
   } else {
-    const topic = args.topic ?? (await d.askTopic())?.trim();
-    if (!topic) throw new PeriscopeError("a topic is required: pass --topic TEXT");
+    const topic = args.topic ?? (await d.askTopic())?.trim() ?? defaultTopic(args.repo, d.now());
     const unsafe = d.baseProblem();
     if (unsafe) throw new PeriscopeError(`DO NOT CUT A WORKTREE FROM THIS BASE \u2014 ${unsafe}`);
     draft = await d.fileDraft(`Periscope: ${topic}`);
@@ -16755,22 +16870,25 @@ ${tail(preview.output)}`);
   };
 }
 function parsePeriscopeDownArgs(positional2, flags) {
-  const usage2 = "usage: crew periscope down [route] NNN --keep|--discard [--allow-empty] [--json]";
+  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 (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
+  const m = rest.length === 0 ? null : /^(?:[A-Za-z]+-)?(\d+)$/.exec(rest[rest.length - 1]);
+  if (rest.length > 0 && !m) throw new PeriscopeError(`"${rest[rest.length - 1]}" is not a ticket number
 ${usage2}`);
   return {
     ...rest.length === 2 ? { route: rest[0] } : {},
-    number: m[1],
+    ...m ? { number: m[1] } : {},
     mode: flags.keep ? "keep" : "discard",
     allowEmpty: flags.allowEmpty,
     json: flags.json
   };
 }
+function rowForCwd(rows, cwd) {
+  return rows.find((r) => r.state === "live" && r.worktree !== "" && (cwd === r.worktree || cwd.startsWith(`${r.worktree}/`)));
+}
 var PROTOTYPE_HEADING = "## Prototype";
 function prototypeSection(files) {
   const added = files.reduce((n, f) => n + f.added, 0);
@@ -18509,12 +18627,13 @@ function usage(problem, requested = false) {
   crew reap [route]              kill orphaned servers, drop worktrees for closed tickets
   crew drop [route] NNN          remove a merged ticket's worktree and branch
   crew rotate-passenger-url [route]   force a Host Passengers tunnel to reconnect with a fresh public URL
-  crew periscope up [route] REPO --topic TEXT|--issue NNN [--isolate] [--host H] [--assignee ID] [--dry-run] [--json]
+  crew periscope up [[route] REPO] [--topic TEXT|--issue NNN] [--isolate] [--host H] [--assignee ID] [--no-open] [--open] [--dry-run] [--json]
   crew periscope up --resume NNN restart the preview an idle periscope's server was stopped for
                                  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]
+  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 shell-init [--shell zsh|bash|fish]   print the periscope shell function (install: eval "$(crew shell-init)")
   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
@@ -18620,6 +18739,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "run",
   "sample-ticket",
   "selftest",
+  "shell-init",
   "ship",
   "skills",
   "status",
@@ -18631,6 +18751,16 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "worktree"
 ]);
 if (!KNOWN_COMMANDS.has(command)) usage(`unknown command "${command}"`);
+if (command === "shell-init") {
+  const asked = value("shell");
+  if (asked !== void 0 && !SHELLS.includes(asked)) {
+    process.stderr.write(`crew shell-init: unknown shell "${asked}" (have: ${SHELLS.join(", ")})
+`);
+    process.exit(2);
+  }
+  process.stdout.write(shellInitScript(shellFor(asked, process.env.SHELL)));
+  process.exit(0);
+}
 function runReposCheck(dir, ship) {
   const report = checkRepoSpec(dir, { ship, strict: flag("strict") });
   if (flag("json")) {
@@ -21956,8 +22086,8 @@ 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" && subP !== "down" && subP !== "end" && subP !== "list") {
-        process.stderr.write("crew periscope up [route] REPO --topic TEXT|--issue NNN [--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 up [[route] REPO] [--topic TEXT|--issue NNN] [--isolate] [--host H] [--assignee ID] [--no-open] [--open] [--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);
       }
@@ -22002,11 +22132,27 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
             break;
           }
-          const a = downArgs;
+          const real = (p) => {
+            try {
+              return realpathSync3(p);
+            } catch {
+              return p;
+            }
+          };
+          const gathered = await Promise.all(routesP.map(async (rt) => ({ rt, rows: await gather(rt) })));
+          const number = downArgs.number ?? (() => {
+            const here = real(process.cwd());
+            for (const g of gathered) {
+              const hit = rowForCwd(g.rows.map((r) => ({ ...r, worktree: real(r.worktree) })), here);
+              if (hit) return hit.number;
+            }
+            throw new PeriscopeError("not inside a periscope worktree \u2014 name the ticket: crew periscope down NNN --keep|--discard");
+          })();
+          const a = { ...downArgs, number };
           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 });
+          for (const g of gathered) {
+            const rows = g.rows.filter((r) => r.number === a.number);
+            if (rows.length) hits.push({ rt: g.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`);
@@ -22085,6 +22231,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             say("dry-run", `would end the periscope for ${rowsD[0].ticket} (${a.mode})`);
             break;
           }
+          process.chdir(repoD.dir);
           const res = await runPeriscopeDown(depsD, a);
           if (jsonP) process.stdout.write(`${JSON.stringify({ event: "done", ...res })}
 `);
@@ -22142,7 +22289,19 @@ ${resumed.url}
 `);
           break;
         }
-        const a = parsePeriscopeUpArgs(positional, { topic: value("topic"), issue: value("issue"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
+        const parsedUp = parsePeriscopeUpArgs(positional, { topic: value("topic"), issue: value("issue"), host: value("host"), assignee: value("assignee"), isolate: flag("isolate"), json: jsonP });
+        let a;
+        if (parsedUp.repo !== void 0) a = { ...parsedUp, repo: parsedUp.repo };
+        else {
+          const here = locateDir(cfg, process.cwd(), (d) => gitOk(d, ["rev-parse", "--path-format=absolute", "--git-common-dir"]) ?? void 0);
+          if (!here) {
+            const where = cfg.routes.flatMap((r) => reposOf(r).map((x) => `  ${x.name}: ${x.dir}`));
+            throw new PeriscopeError(`run it from inside a configured checkout, or name the repository (crew periscope up REPO). Configured checkouts:
+${where.join("\n")}`);
+          }
+          a = { ...parsedUp, repo: here.repo.name, route: parsedUp.route ?? here.route.route };
+        }
+        const terminal = !!process.stdin.isTTY && !!process.stdout.isTTY && !jsonP;
         const candidatesP = a.route ? [findRoute(cfg, a.route)] : cfg.routes.filter((r) => r.enabled);
         const servedP = [];
         for (const cand of candidatesP) {
@@ -22174,10 +22333,11 @@ ${resumed.url}
             return h.unsafe ? h.detail : void 0;
           },
           askTopic: async () => {
-            if (!process.stdin.isTTY || jsonP) return void 0;
+            if (!terminal) return void 0;
             const rl = createInterface({ input: process.stdin, output: process.stderr });
             try {
-              return await rl.question("Periscope topic: ");
+              const answer = (await rl.question(`Periscope topic for ${a.repo} (blank for "${defaultTopic(a.repo, /* @__PURE__ */ new Date())}"): `)).trim();
+              return answer || void 0;
             } finally {
               rl.close();
             }
@@ -22283,16 +22443,21 @@ ${resumed.url}
             say("dry-run", `would hold ${t.tag} (status ${t.status} stays) for ${pairId}, cut or reuse its worktree for ${a.repo}, run setup${a.isolate ? ", isolate" : ""}, ports, handoff and preview on ${deps.host}, and record a Periscopes row`);
             break;
           }
-          say("dry-run", `would file "Periscope: ${a.topic ?? "<topic>"}" as ${cP.statuses.draft} for ${pairId}, cut a worktree for ${a.repo}, run setup${a.isolate ? ", isolate" : ""}, ports, handoff and preview on ${deps.host}, and record a Periscopes row (expires after ${caps.idleMinutes} minutes idle)`);
+          say("dry-run", `would file "Periscope: ${a.topic ?? defaultTopic(a.repo, /* @__PURE__ */ new Date())}" as ${cP.statuses.draft} for ${pairId}, cut a worktree for ${a.repo}, run setup${a.isolate ? ", isolate" : ""}, ports, handoff and preview on ${deps.host}, and record a Periscopes row (expires after ${caps.idleMinutes} minutes idle)`);
           break;
         }
         const res = await runPeriscopeUp(deps, a);
         if (jsonP) process.stdout.write(`${JSON.stringify({ event: "done", ...res })}
 `);
-        else process.stdout.write(`${res.ticket}
-${res.worktree}
-${res.url}
+        else {
+          process.stdout.write(upOutput(res, terminal));
+          const opener = openerFor(process.platform);
+          if (opener && shouldOpen({ open: flag("open"), noOpen: flag("no-open"), json: jsonP, terminal })) {
+            const r = spawnSync7(opener, [res.url], { stdio: "ignore" });
+            if (r.error || r.status !== 0) process.stderr.write(`crew periscope: could not open ${res.url} with ${opener}
 `);
+          }
+        }
       } catch (e) {
         if (e instanceof PeriscopeError || e instanceof ConfigError) {
           process.stderr.write(`crew periscope: ${e.message}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.89.0",
+  "version": "0.90.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",