@dylanpiercey/work 0.2.16 → 0.2.18

package/bin/cli/skill.mjs

@@ -0,0 +1,99 @@
+// `work skill`: the machine's skills — what every agent CLI here can see —
+// as Settings → Skills lists, adds, updates and removes them.
+import { follow } from "./_progress.mjs";
+
+function printList(snap) {
+  const rows = snap.global || [];
+  if (!snap.available)
+    console.log(
+      "the skills CLI is not installed, so skills can be listed but not added (work setup installs it)",
+    );
+  if (!rows.length) return console.log("no skills installed");
+  const w = Math.max(4, ...rows.map((s) => s.id.length));
+  for (const s of rows) {
+    const from = s.source ? `  ${s.source}` : "";
+    const broken = s.broken ? "  (broken link)" : "";
+    console.log(`${s.id.padEnd(w)}${from}${broken}`);
+    if (s.description) console.log(`${"".padEnd(w)}  ${s.description}`);
+  }
+}
+
+/** One skill action through the route Settings uses, its progress (the
+ * skills CLI's own output) on stderr; the machine's skills after it. */
+function act(ctx, body, op) {
+  return follow(ctx, op, () => ctx.api.post("/api/skills", body));
+}
+
+/** @type {Array<{name: string, summary: string, help: string, run: (ctx: any) => Promise<void>}>} */
+export const commands = [
+  {
+    name: "skill",
+    summary: "machine skills: list | add | rm | update",
+    help: `work skill [list]
+  The skills every agent CLI on this machine can see (Settings → Skills):
+  each one's id, where it came from, and what it does.
+work skill add <source> [--skill <name>]
+  Add skills from a source the skills CLI understands (owner/repo, a git
+  URL, a path): every skill it ships, or the one --skill names.
+work skill rm <id>
+  Remove an installed skill.
+work skill update [<id>]
+  Update one skill from its source, or every skill that has one.`,
+    async run(ctx) {
+      const [verb = "list", arg] = ctx.parse(["--skill"]);
+      if (verb === "list") {
+        const snap = await ctx.api.get("/api/skills");
+        return ctx.out(snap.global || [], () => printList(snap));
+      }
+      if (verb === "add") {
+        if (!arg) ctx.die("name the source: work skill add <owner/repo|url>");
+        const skill = ctx.args.includes("--skill")
+          ? ctx.flag("--skill")
+          : undefined;
+        const snap = await act(
+          ctx,
+          { action: "add", source: arg, skill },
+          `skills:${skill ? `${arg}#${skill}` : arg}`,
+        );
+        return ctx.out(snap.global || [], () =>
+          console.log(
+            `added ${skill ?? "the skills of"} ${skill ? "from " : ""}${arg}`,
+          ),
+        );
+      }
+      if (verb === "rm" || verb === "remove") {
+        if (!arg) ctx.die("name the skill: work skill rm <id>");
+        const snap = await act(
+          ctx,
+          { action: "remove", id: arg },
+          `skills:${arg}`,
+        );
+        return ctx.out(snap.global || [], () => console.log(`removed ${arg}`));
+      }
+      if (verb === "update") {
+        let ids = arg ? [arg] : [];
+        if (!arg) {
+          const snap = await ctx.api.get("/api/skills");
+          ids = (snap.global || [])
+            .filter((s) => s.source && s.source !== "local")
+            .map((s) => s.id);
+          if (!ids.length) {
+            ctx.out([], () =>
+              console.log("no skill has a source to update from"),
+            );
+            return;
+          }
+        }
+        let snap = null;
+        for (const id of ids) {
+          process.stderr.write(`  updating ${id}\n`);
+          snap = await act(ctx, { action: "update", id }, `skills:${id}`);
+        }
+        return ctx.out(snap?.global || [], () =>
+          console.log(`updated ${ids.join(", ")}`),
+        );
+      }
+      ctx.die(`no skill verb ${verb} (list, add, rm, update)`);
+    },
+  },
+];

package/bin/cli/stack.mjs

@@ -0,0 +1,51 @@
+// `work stack`: how to stack branches here, with this workspace's branch
+// in place. Kept out of the workspace AGENTS.md, which every session reads
+// whole: stacking is for when the user asks, and the recipe was a quarter
+// of that file.
+
+function recipe(branch) {
+  return `Stacking ${branch}
+
+Stack only when the user asks, or when a change of several hundred lines
+splits into parts each worth merging alone; never a layer per commit.
+
+- The working branch (${branch}) stays the top; cut layers below it, bottom
+  first, as ${branch}-<layer>:
+    gh stack init --base <base> <layers…> ${branch}
+  (after \`gh stack unstack --local\` if a stack exists).
+- Never check a layer out. Edit one by \`git commit --fixup <sha>\` on the
+  top, then:
+    GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash --update-refs origin/<base>
+- \`gh stack sync\` / \`gh stack rebase\` switch branches: run them in topic
+  worktrees only. Leave the local <base> gh-stack keeps as trunk.
+- Merge a layer with \`gh stack merge <pr> --squash\` or on the web
+  (\`gh pr merge\` refuses it), then, on the top:
+    old=$(git rev-parse origin/${branch})
+    git fetch
+    git branch -f <layer> origin/<layer>     # for each remaining layer
+    git branch -D <merged-layer>
+    git rebase --onto origin/${branch} $old
+- Once the top merges: \`gh stack unstack --local\`.
+- Link a layer for review as [<layer>](/w/<id>/review?section=<repo>@<layer>);
+  \`work branches\` lists every layer with its link.`;
+}
+
+export const commands = [
+  {
+    name: "stack",
+    summary: "how to stack branches in this workspace (prints the recipe)",
+    help: `work stack [id|name]
+  Prints how to stack branches with gh-stack here, with the workspace's
+  branch filled in: when to, cutting layers, editing one without checking
+  it out, merging a layer and rebasing the rest.`,
+    async run(ctx) {
+      let branch = "<workspace-branch>";
+      try {
+        if (ctx.positional[0] || process.env.WORK_SESSION_ID) {
+          branch = (await ctx.resolveWorkspace(ctx.positional[0])).ws.branch;
+        }
+      } catch {}
+      ctx.out({ branch, recipe: recipe(branch) }, (d) => console.log(d.recipe));
+    },
+  },
+];

package/bin/cli/status.mjs

@@ -0,0 +1,86 @@
+// `work status`: the machine and the service in one look — how the server
+// runs (its own config, not the unit file's), the agents, language servers
+// and skills, what `work doctor` would say is missing, and the settings
+// changed from their defaults. One request each, side by side.
+import { shown } from "./config.mjs";
+
+export const commands = [
+  {
+    name: "status",
+    summary: "the service, agents, languages, skills and changed settings",
+    help: `work status [--json]
+    one snapshot of this machine's work: version, address and names it
+    answers to, direct connections, data and work root, agents (installed,
+    switched off, the default), language servers, skills, what is missing
+    (work doctor), and the settings changed from their defaults`,
+    async run(ctx) {
+      const [server, settings, agents, lsp, skills, setup] = await Promise.all([
+        ctx.api.get("/api/config"),
+        ctx.api.get("/api/settings/values"),
+        ctx.api.get("/api/settings"),
+        ctx.api.get("/api/lsp"),
+        ctx.api.get("/api/skills"),
+        ctx.api.get("/api/setup"),
+      ]);
+      const snapshot = {
+        version: server.version,
+        server,
+        agents: {
+          default: agents.preferredAgent,
+          enabled: agents.agents,
+          disabled: agents.disabledAgents,
+          installable: (setup.agents || [])
+            .filter((a) => !a.installed)
+            .map((a) => a.id),
+        },
+        languages: {
+          on: lsp.on,
+          installed: lsp.servers.filter((s) => s.installed).map((s) => s.id),
+          off: lsp.servers.filter((s) => !s.enabled).map((s) => s.id),
+        },
+        skills: [...(skills.global || [])].map((s) => s.id ?? s.name ?? s),
+        doctor: { ready: setup.ready, missing: setup.missing },
+        settings: settings.filter((e) => !e.isDefault),
+      };
+      ctx.out(snapshot, (s) => {
+        const sv = s.server;
+        const list = (xs) => (xs.length ? xs.join(", ") : "none");
+        const rows = [
+          ["work", `${s.version} on ${sv.listen}:${sv.port}`],
+          [
+            "names",
+            sv.allowedHosts.length
+              ? `${sv.allowedHosts.join(", ")} (ports as ${sv.portHosts === "dash" ? "<port>-<name>" : "<port>.<name>"})`
+              : "this machine's own",
+          ],
+          ["proxies", list(sv.trustedProxies)],
+          ["direct", sv.rtc.on ? `on, UDP ${sv.rtc.port}` : "off"],
+          ["root", sv.workRoot],
+          ["data", sv.dataDir],
+          [
+            "agents",
+            `${list(s.agents.enabled)}; default ${s.agents.default}${s.agents.disabled.length ? `; off: ${s.agents.disabled.join(", ")}` : ""}`,
+          ],
+          [
+            "languages",
+            `${s.languages.on ? "on" : "off"}; installed: ${list(s.languages.installed)}${s.languages.off.length ? `; off: ${s.languages.off.join(", ")}` : ""}`,
+          ],
+          ["skills", list(s.skills)],
+          [
+            "machine",
+            s.doctor.ready
+              ? "ready"
+              : `not ready: ${list(s.doctor.missing)} (work doctor)`,
+          ],
+          [
+            "settings",
+            s.settings.length
+              ? s.settings.map((e) => `${e.key}=${shown(e.value)}`).join(", ")
+              : "all at their defaults (work config list)",
+          ],
+        ];
+        for (const [k, v] of rows) console.log(`${ctx.pad(k, 10)} ${v}`);
+      });
+    },
+  },
+];