dsh-git-badge 0.14.1 → 0.16.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "dsh-git-badge",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Git status badges for DeepSeek Harness: an input-row chip on every install, plus sidebar session-row badges (git status, PR/CI action tokens) after one manual step: `npx dsh-git-badge apply`, then restart dsh web. Event-driven freshness over SSE.",
   "type": "module",
   "main": "lib/index.js",
   "bin": {
-    "dsh-git-badge-seam": "seam/apply.js"
+    "dsh-git-badge-seam": "seam/apply.js",
+    "dsh-git-badge-checkout": "seam/checkout.js"
   },
   "exports": {
     ".": "./lib/index.js",
@@ -56,10 +57,14 @@
     "package.json",
     "seam/anchors.js",
     "seam/apply.js",
+    "seam/checkout.js",
     "seam/postinstall.js",
     "seam/skill.js",
     "seam/store.js",
     "seam/stub-index.js",
     "skill/gh/SKILL.md"
-  ]
+  ],
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2"
+  }
 }

package/seam/checkout.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * dsh-git-badge-checkout — tell the badge which checkout THIS session is working
+ * in.
+ *
+ * WHY THIS EXISTS: a dsh session's cwd is immutable creation metadata — it is
+ * the main checkout forever, even after the agent does its work in a linked
+ * worktree. The badge therefore cannot know, on its own, that a session moved
+ * into `.wt/<name>`; it can only infer a worktree from an open pull request.
+ * This command closes that gap: the agent registers the checkout explicitly, and
+ * the node half prefers the registration over inference.
+ *
+ * The registration is advisory and self-expiring (24h) — never let it fail the
+ * work that earned it:
+ *
+ *   usage:  npx dsh-git-badge-checkout <path>     register this session
+ *           npx dsh-git-badge-checkout --clear    forget this session
+ *
+ * The path is validated as a real worktree of its repository before it is
+ * written, so a typo cannot point the badge at an unrelated directory.
+ */
+import { execFileSync } from "node:child_process";
+import { basename, resolve } from "node:path";
+import { clearSessionCheckout, writeSessionCheckout } from "./store.js";
+
+function usage(message) {
+	if (message !== void 0) console.error(message);
+	console.error("usage: dsh-git-badge-checkout <path> | --clear");
+}
+
+/** Worktree paths git lists for the repo containing `dir`. */
+function worktreePaths(dir) {
+	const out = execFileSync("git", ["-C", dir, "worktree", "list", "--porcelain"], { encoding: "utf8" });
+	return out
+		.split("\n")
+		.filter((line) => line.startsWith("worktree "))
+		.map((line) => resolve(line.slice("worktree ".length).trim()));
+}
+
+function branchOf(dir) {
+	try {
+		return execFileSync("git", ["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" }).trim();
+	} catch {
+		return "unknown";
+	}
+}
+
+const sessionId = process.env.DSH_SESSION_ID;
+if (sessionId === void 0 || sessionId === "") {
+	usage("no DSH_SESSION_ID in the environment — run this from inside a dsh session.");
+	process.exit(2);
+}
+
+const arg = process.argv[2];
+if (arg === "--clear") {
+	clearSessionCheckout(sessionId);
+	console.log("[dsh-git-badge] checkout registration cleared for this session.");
+	process.exit(0);
+}
+if (arg === void 0 || arg === "") {
+	usage();
+	process.exit(2);
+}
+
+const path = resolve(arg);
+let paths;
+try {
+	paths = worktreePaths(path);
+} catch (error) {
+	console.error(`[dsh-git-badge] ${path} is not a git worktree: ${String(error?.message ?? error)}`);
+	process.exit(1);
+}
+if (!paths.includes(path)) {
+	console.error(`[dsh-git-badge] ${path} is not a worktree of its repository (git lists: ${paths.join(", ")})`);
+	process.exit(1);
+}
+
+if (!writeSessionCheckout(sessionId, path)) {
+	console.error("[dsh-git-badge] could not write the registration; the badge keeps its inferred checkout.");
+	process.exit(1);
+}
+console.log(`[dsh-git-badge] this session's checkout is now ${basename(path)} (${branchOf(path)}).`);

package/seam/store.js

@@ -1,4 +1,13 @@
 /**
+ * Two out-of-band stores live here, both keyed files under dataDir():
+ *
+ *   restart-pending.json    install/applied a host patch → the UI offers a restart
+ *   session-checkouts.json  which checkout a SESSION is working in — the one
+ *                           fact dsh cannot supply (a session's cwd is immutable
+ *                           creation metadata and always the main checkout, so a
+ *                           session working in a linked worktree is invisible
+ *                           without an explicit registration)
+ *
  * The restart-pending marker — the bridge from install-time (node side) to the
  * running UI.
  *
@@ -68,4 +77,60 @@ export function clearRestartMarker() {
 	} catch {
 		// Absent is the goal; any error leaves the marker to be cleared later.
 	}
-}
+}
+/** How long a session-checkout registration stays trustworthy. */
+export const SESSION_CHECKOUT_TTL_MS = 24 * 60 * 60 * 1000;
+
+function sessionCheckoutsPath() {
+	return join(dataDir(), "session-checkouts.json");
+}
+
+/** Every registration, `{ sessionId: { path, at } }`. Never throws. */
+export function readSessionCheckouts() {
+	try {
+		if (!existsSync(sessionCheckoutsPath())) return {};
+		const raw = JSON.parse(readFileSync(sessionCheckoutsPath(), "utf8"));
+		return raw !== null && typeof raw === "object" && typeof raw.sessions === "object" && raw.sessions !== null
+			? raw.sessions
+			: {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Register the checkout a session is working in. Written by the agent (the
+ * git-worktree and /gh checkout paths), read by the node half.
+ */
+export function writeSessionCheckout(sessionId, path) {
+	try {
+		mkdirSync(dataDir(), { recursive: true });
+		const sessions = readSessionCheckouts();
+		sessions[sessionId] = { path, at: new Date().toISOString() };
+		writeFileSync(
+			sessionCheckoutsPath(),
+			JSON.stringify({ schema: "dsh-git-badge/session-checkout/v1", sessions }),
+			"utf8",
+		);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/** Forget one session's registration (worktree removed, or the session left). */
+export function clearSessionCheckout(sessionId) {
+	try {
+		const sessions = readSessionCheckouts();
+		if (!(sessionId in sessions)) return true;
+		delete sessions[sessionId];
+		writeFileSync(
+			sessionCheckoutsPath(),
+			JSON.stringify({ schema: "dsh-git-badge/session-checkout/v1", sessions }),
+			"utf8",
+		);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/skill/gh/SKILL.md

@@ -59,6 +59,52 @@ unstaged / untracked / unmerged), plus any in-progress operation marker
 - **`/gh checks <n>`** — `gh pr checks <n>` and summarise: what fails, what is
   pending, and the single most useful next step.
 
+- **`/gh sync`** — the branch has diverged (local commits AND upstream
+  changes): `git fetch`, then rebase the local commits onto
+  `upstream/<branch>`, then `git push --force-with-lease`. The force-push
+  ALWAYS needs an explicit user yes first, with a one-line summary of what
+  would move.
+
+- **`/gh merge <n>`** — squash-merge pull request `<n>` (`gh pr merge <n>
+  --squash`), the repo's stated convention. Confirm with the user before
+  merging; afterwards report the merge and offer to update the local main.
+
+- **`/gh stash pop`** — with stashes present: show the top entry's subject,
+  confirm with the user, then `git stash pop`. If pop conflicts, report the
+  conflict verbatim and note that the stash is NOT dropped — suggest
+  `git stash apply` as the retry that keeps it.
+
+- **`/gh checkout <branch>`** — switch to an existing local branch. Establish
+  state first: uncommitted changes may block or travel with the checkout — say
+  what is dirty and confirm the switch when work would carry over. Unknown
+  branch → say so and list the closest local names.
+
+  If the switch lands you in — or out of — a linked worktree, register where you
+  are so the session badge follows the right checkout:
+  `npx dsh-git-badge-checkout "$(git rev-parse --show-toplevel)"` (best effort;
+  ignore failure). Clearing back to the main checkout is the same command run
+  against the main worktree — the badge treats the main checkout as the default.
+  A session's cwd is fixed at creation, so this registration is the ONLY signal
+  the badge has.
+
+- **`/gh order`** — reconfigure which action class the badge ranks first. The
+  order lives in the `git-badge` settings namespace, edited in the UI at
+  **Settings → Plugins → Git Badge** (an ordered list with up/down controls).
+  When the request comes through the agent instead, read the current value from
+  the settings document (`~/.dsh/settings.yaml`, the `git-badge:` section) and
+  change that `order` list — any subset, any order; unlisted categories rank
+  after in default order. Never invent categories. The older
+  `~/.dsh/git-badge-next.json` is only a fallback for hosts without the
+  settings stack; do not edit it when the namespace is present. Typical
+  invocations: "/gh order commit first", "/gh order never suggest checks
+  before push".
+
+## Handoff
+
+One verb per invocation is this skill's whole job. Anything multi-step around a
+pull request — review, merge, verify it landed, clean up the branch — belongs to
+the `gh-pr` skill; hand off rather than improvise a lifecycle.
+
 ## Hard rules
 
 - Never `git reset --hard`, `git clean`, `git checkout -- .`, `git push