@harborppm/cli 0.95.0 → 0.97.0

package/lib/cli.mjs

@@ -54,6 +54,8 @@ import {
   catchupText,
   handoverText,
   fogText,
+  scuttleText,
+  scuttleCallText,
   agentWorkText,
   raidDetail,
   raidList,
@@ -295,6 +297,13 @@ export const HELP = `harbor: Harbor from the terminal
   harbor fog --sweep [--project P]            one at a time: still needed, a
                                               new date, or drop it
   harbor fog keep TASK                        it's still needed: out of the fog
+  harbor scuttle [--program P|--portfolio P]  projects that look adrift: still
+                                              for weeks, slipping, long late
+  harbor scuttle sail|refit PROJECT [--end DATE] [--note TEXT]
+                                              keep it, or refit it, for three
+                                              months out of the line-up
+  harbor scuttle PROJECT --why "TEXT"         stop it on purpose: Done, on the
+                                              register, its tasks set free
   harbor watch [--project P] [--bell]         a live ticker of the harbor's
                                               changes; yours bright, q stops
   harbor watch --once [--since TIME] [--json] the latest changes (or all since
@@ -1149,6 +1158,24 @@ const DETAIL = {
     "  The sweep needs a terminal and full access (harbor login without",
     "  --read-only), since dropping a task deletes it.",
   ],
+  scuttle: [
+    "  harbor scuttle [--program P]           reads: running projects that look",
+    "                 [--portfolio P]         adrift (nothing moved for four",
+    "                                         weeks, slipping again and again, long",
+    "                                         past the end, paused for a month),",
+    "                                         and what stopping each would free",
+    "  harbor scuttle sail PROJECT            writes: keep it sailing; it leaves",
+    "                                         the line-up for three months",
+    "  harbor scuttle refit PROJECT           writes: a new end date and/or a line",
+    '                 [--end DATE] [--note "TEXT"]  on what changes',
+    '  harbor scuttle PROJECT --why "TEXT"    writes: stop it. It closes as Done',
+    "                                         with the why as its note, a decision",
+    "                                         goes on the register, and its open",
+    "                                         tasks come off people's lists",
+    "",
+    "  Nothing is deleted: harbor health auto --project P raises a scuttled project",
+    "  again and gives its tasks back.",
+  ],
   watch: [
     "  harbor watch                           reads, live: each change to the harbor",
     "                                         as it lands, one line with its time",
@@ -3579,6 +3606,49 @@ export async function run(argv, io = {}) {
       }
       return call("fog", { harbor, project: values.project, limit: 100 }, (r) => fogText(r));
     }
+    case "scuttle": {
+      const { positionals, values, harbor } = parse(
+        spec(["list"], ["program", "portfolio", "end", "note", "why"]),
+      );
+      const [first, ...rest] = positionals;
+      if (first === "sail" || first === "refit") {
+        if (values.why !== undefined)
+          throw new HarborError(`--why goes with scuttling: harbor scuttle PROJECT --why "TEXT".`);
+        const project = one(rest, "project");
+        if (first === "sail" && (values.end !== undefined || values.note !== undefined))
+          throw new HarborError("--end and --note go with a refit: harbor scuttle refit PROJECT --end DATE.");
+        if (first === "refit" && values.end === undefined && values.note === undefined)
+          throw new HarborError('A refit needs --end DATE or --note "what changes".');
+        return call(
+          "answer_scuttle_or_sail",
+          {
+            harbor,
+            project,
+            call: first,
+            ...(values.end !== undefined ? { endDate: dueDate(values.end) } : {}),
+            ...(values.note !== undefined ? { note: values.note } : {}),
+          },
+          scuttleCallText,
+        );
+      }
+      if (first !== undefined) {
+        const project = one(positionals, "project");
+        if (values.why === undefined || !values.why.trim())
+          throw new HarborError(
+            `Say why it stops: harbor scuttle ${project} --why "TEXT". To keep it: harbor scuttle sail ${project}.`,
+          );
+        return call(
+          "answer_scuttle_or_sail",
+          { harbor, project, call: "scuttle", why: values.why },
+          scuttleCallText,
+        );
+      }
+      return call(
+        "scuttle_or_sail",
+        { harbor, program: values.program, portfolio: values.portfolio, limit: 100 },
+        scuttleText,
+      );
+    }
     case "bridge": {
       const { positionals, values, harbor } = parse(spec(["list"], ["program"]));
       none(positionals);

package/lib/format.mjs

@@ -1124,6 +1124,45 @@ export function fogText(r, { sweepHint = true } = {}) {
   return lines.join("\n");
 }
 
+/** harbor scuttle: projects that look adrift, with what stopping each would free. */
+export function scuttleText(r) {
+  const where = r.program ? ` in ${r.program}` : r.portfolio ? ` in ${r.portfolio}` : "";
+  if (!r.adrift)
+    return `Nothing looks adrift${where}: every running project has moved lately, and none keeps slipping.`;
+  const lines = [
+    `${r.adrift} ${r.adrift === 1 ? "project looks" : "projects look"} adrift${where}. Keep each sailing, refit it, or stop it on purpose.`,
+    "",
+  ];
+  for (const p of r.projects) {
+    lines.push(
+      `  ${(p.key ?? "").padEnd(5)} ${p.project}${p.owner ? ` · ${p.owner}` : ""} · ends ${p.endDate}`,
+    );
+    for (const s of p.signs) lines.push(`        ${s.text}`);
+    const frees = [
+      `${p.openTasks} open task${p.openTasks === 1 ? "" : "s"}`,
+      p.crew.length ? `with ${p.crew.map((c) => c.person).filter(Boolean).join(", ")}` : null,
+      p.hoursPerWeek ? `${p.hoursPerWeek}h a week logged` : null,
+      p.spendPerWeek ? `$${p.spendPerWeek.toLocaleString("en-US")} a week of spend` : null,
+    ];
+    lines.push(`        holds ${frees.filter(Boolean).join(" · ")}`);
+  }
+  if (r.more) lines.push("", `And ${r.adrift - r.projects.length} more.`);
+  lines.push(
+    "",
+    'harbor scuttle sail PROJECT keeps one, harbor scuttle refit PROJECT --end DATE refits it, harbor scuttle PROJECT --why "TEXT" stops it.',
+  );
+  return lines.join("\n");
+}
+
+/** What harbor scuttle sail, refit or PROJECT --why did. */
+export function scuttleCallText(r) {
+  if (r.call === "scuttle")
+    return `Scuttled ${r.project}. ${r.sendOff} The why is on the register as a decision; harbor health auto --project "${r.project}" raises it again.`;
+  if (r.call === "refit")
+    return `Refitted ${r.project}: ${r.note ?? `ends ${r.endDate}`}. It's out of the line-up until ${r.quietUntil}.`;
+  return `${r.project} sails on. It's out of the line-up until ${r.quietUntil}.`;
+}
+
 /** harbor lifeboats: work only one person knows, numbered for harbor lifeboats N. */
 export function lifeboatsText(r) {
   const where = r.program ? ` in ${r.program}` : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harborppm/cli",
-  "version": "0.95.0",
+  "version": "0.97.0",
   "description": "Harbor from the terminal: a full-screen app with everything, plus commands for scripts and agents.",
   "keywords": [
     "harbor",