@jaggerxtrm/pi-extensions 0.7.8

package/MIGRATION_NOTES.md

@@ -0,0 +1,39 @@
+# Pi extension source migration notes (P2)
+
+## Legacy → new source map
+
+| Legacy path | New path | Notes |
+|---|---|---|
+| `packages/pi-extensions/extensions/auto-session-name` | `packages/pi-extensions/extensions/auto-session-name` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/auto-update` | `packages/pi-extensions/extensions/auto-update` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/beads` | `packages/pi-extensions/extensions/beads` | now imports `../../src/core` |
+| `packages/pi-extensions/extensions/compact-header` | `packages/pi-extensions/extensions/compact-header` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/custom-footer` | `packages/pi-extensions/extensions/custom-footer` | now imports `../../src/core` |
+| `packages/pi-extensions/extensions/custom-provider-qwen-cli` | `packages/pi-extensions/extensions/custom-provider-qwen-cli` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/git-checkpoint` | `packages/pi-extensions/extensions/git-checkpoint` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/lsp-bootstrap` | `packages/pi-extensions/extensions/lsp-bootstrap` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/pi-serena-compact` | `packages/pi-extensions/extensions/pi-serena-compact` | extension source moved unchanged |
+| `packages/pi-extensions/extensions/quality-gates` | `packages/pi-extensions/extensions/quality-gates` | now imports `../../src/core` |
+| `packages/pi-extensions/extensions/service-skills` | `packages/pi-extensions/extensions/service-skills` | now imports `../../src/core` |
+| `packages/pi-extensions/extensions/session-flow` | `packages/pi-extensions/extensions/session-flow` | now imports `../../src/core` |
+| `packages/pi-extensions/extensions/xtrm-loader` | `packages/pi-extensions/extensions/xtrm-loader` | now imports `../../src/core` |
+| `packages/pi-extensions/extensions/xtrm-ui` | `packages/pi-extensions/extensions/xtrm-ui` | theme assets moved to package-level `themes/xtrm-ui` |
+| `packages/pi-extensions/src/core` | `packages/pi-extensions/src/core` | internal helpers; no separate `@xtrm/pi-core` package required |
+
+## Asset migration
+
+- `xtrm-ui/themes/*.json` moved to `packages/pi-extensions/themes/xtrm-ui/*.json`.
+- `xtrm-ui` now discovers themes from `join(__dirname, "../../themes/xtrm-ui")`.
+
+## Follow-up updates required in later phases
+
+1. **Installer/runtime sync paths**
+   - Replace hardcoded `packages/pi-extensions/extensions/**` references with `packages/pi-extensions/extensions/**` in install/runtime copy logic.
+2. **Registry generation**
+   - Update `scripts/gen-registry.mjs` asset sources once package path is the canonical source-of-truth.
+3. **Tests and fixtures**
+   - Update tests asserting extension source paths (currently expecting `packages/pi-extensions/extensions`).
+4. **Policies/docs references**
+   - Update docs/policies that still mention `packages/pi-extensions/extensions` after runtime switch lands.
+5. **Packaging entrypoint wiring**
+   - Wire `packages/pi-extensions/src/index.ts` into Pi package install flow and extension registration.

package/README.md

@@ -0,0 +1,43 @@
+# @jaggerxtrm/pi-extensions
+
+Unified runtime package for xtrm-managed Pi extensions.
+
+## Publish contract
+
+- Package is published as `@jaggerxtrm/pi-extensions` (public npm package).
+- No build step is required. Pi loads raw TypeScript extension entrypoints at runtime.
+- `prepublishOnly` runs `verify:runtime` to ensure required runtime assets exist:
+  - `src/index.ts`
+  - `src/registry.ts`
+  - `extensions/`
+  - `themes/`
+- Files shipped to npm are controlled by `files` in `package.json`.
+
+## Release workflow
+
+From repository root:
+
+```bash
+npm run release:pi-extensions
+```
+
+To publish both root `xtrm-tools` and this package in one pass:
+
+```bash
+npm run release:all
+```
+
+## Install contract
+
+Managed project runtime install path:
+
+```bash
+pi install npm:@jaggerxtrm/pi-extensions
+```
+
+Pi discovers this package through:
+
+- `keywords: ["pi-package"]`
+- `pi.extensions: ["./src/index.ts"]`
+
+After install, keep `.pi/settings.json` package wiring pointed at `npm:@jaggerxtrm/pi-extensions`.

package/extensions/README.md

@@ -0,0 +1,5 @@
+# Managed Pi extension entrypoints
+
+This directory is the canonical source for managed Pi extension entrypoints.
+
+Runtime delivery is package-based via `npm:@jaggerxtrm/pi-extensions`.

package/extensions/auto-session-name/index.ts

@@ -0,0 +1,29 @@
+/**
+ * oh-pi Auto Session Name Extension
+ *
+ * Automatically names sessions based on the first user message.
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  let named = false;
+
+  pi.on("session_start", async (_event, ctx) => {
+    named = !!pi.getSessionName();
+  });
+
+  pi.on("agent_end", async (event) => {
+    if (named) return;
+    const userMsg = event.messages.find((m) => m.role === "user");
+    if (!userMsg) return;
+    const text = typeof userMsg.content === "string"
+      ? userMsg.content
+      : userMsg.content.filter((b) => b.type === "text").map((b) => (b as { text: string }).text).join(" ");
+    if (!text) return;
+    const name = text.slice(0, 60).replace(/\n/g, " ").trim();
+    if (name) {
+      pi.setSessionName(name);
+      named = true;
+    }
+  });
+}

package/extensions/auto-session-name/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-auto-session-name",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: auto-session-name",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}

package/extensions/auto-update/index.ts

@@ -0,0 +1,71 @@
+/**
+ * oh-pi Auto Update — check for new oh-pi version on session start
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24h
+const STAMP_FILE = join(homedir(), ".pi", "agent", ".update-check");
+
+function readStamp(): number {
+  try { return Number(readFileSync(STAMP_FILE, "utf8").trim()) || 0; } catch { return 0; }
+}
+
+function writeStamp() {
+  try { writeFileSync(STAMP_FILE, String(Date.now())); } catch {}
+}
+
+function getLatestVersion(): string | null {
+  try {
+    return execSync("npm view oh-pi version", { encoding: "utf8", timeout: 8000 }).trim();
+  } catch { return null; }
+}
+
+function getCurrentVersion(): string | null {
+  // Read from the installed package.json
+  try {
+    const pkgPath = join(__dirname, "..", "..", "package.json");
+    if (existsSync(pkgPath)) {
+      return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+    }
+  } catch {}
+  // Fallback: npm list
+  try {
+    const out = JSON.parse(execSync("npm list -g oh-pi --json --depth=0", { encoding: "utf8", timeout: 8000 }));
+    return out.dependencies?.["oh-pi"]?.version ?? null;
+  } catch { return null; }
+}
+
+export function isNewer(latest: string, current: string): boolean {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    // Non-blocking: run check in background
+    setTimeout(async () => {
+      try {
+        if (Date.now() - readStamp() < CHECK_INTERVAL) return;
+        writeStamp();
+
+        const current = getCurrentVersion();
+        const latest = getLatestVersion();
+        if (!current || !latest || !isNewer(latest, current)) return;
+
+        const msg = `oh-pi ${latest} available (current: ${current}). Run: npx oh-pi@latest`;
+        if (ctx.hasUI) {
+          ctx.ui.toast?.(msg) ?? console.log(`\n💡 ${msg}\n`);
+        }
+      } catch {}
+    }, 2000);
+  });
+}

package/extensions/auto-update/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-auto-update",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: auto-update",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}

package/extensions/beads/index.ts

@@ -0,0 +1,232 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter } from "../../src/core";
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+
+	let cachedSessionId: string | null = null;
+	let memoryGateFired = false;
+
+	// Resolve a stable session ID across event types.
+	const getSessionId = (ctx: any): string => {
+		const fromManager = ctx?.sessionManager?.getSessionId?.();
+		const fromContext = ctx?.sessionId ?? ctx?.session_id;
+		const resolved = fromManager || fromContext || cachedSessionId || process.pid.toString();
+		if (resolved && !cachedSessionId) cachedSessionId = resolved;
+		return resolved;
+	};
+
+	const getSessionClaim = async (sessionId: string, cwd: string): Promise<string | null> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `claimed:${sessionId}`], { cwd });
+		if (result.code !== 0) return null;
+		const claim = result.stdout.trim();
+		return claim.length > 0 ? claim : null;
+	};
+
+	const clearClaimMarker = async (sessionId: string, cwd: string) => {
+		await SubprocessRunner.run("bd", ["kv", "clear", `claimed:${sessionId}`], { cwd });
+	};
+
+	const isIssueInProgress = async (issueId: string, cwd: string): Promise<boolean | null> => {
+		const result = await SubprocessRunner.run("bd", ["show", issueId, "--json"], { cwd });
+		if (result.code !== 0 || !result.stdout.trim()) return null;
+		try {
+			const parsed = JSON.parse(result.stdout);
+			const issue = Array.isArray(parsed) ? parsed[0] : parsed;
+			if (!issue?.status) return null;
+			return issue.status === "in_progress";
+		} catch {
+			return null;
+		}
+	};
+
+	const getActiveClaim = async (sessionId: string, cwd: string): Promise<string | null> => {
+		const claim = await getSessionClaim(sessionId, cwd);
+		if (!claim) return null;
+
+		const inProgress = await isIssueInProgress(claim, cwd);
+		if (inProgress === false) {
+			await clearClaimMarker(sessionId, cwd);
+			return null;
+		}
+
+		return claim;
+	};
+
+	const getClosedThisSession = async (sessionId: string, cwd: string): Promise<string | null> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `closed-this-session:${sessionId}`], { cwd });
+		if (result.code !== 0) return null;
+		const issue = result.stdout.trim();
+		return issue.length > 0 ? issue : null;
+	};
+
+	const clearSessionMarkers = async (sessionId: string, cwd: string) => {
+		await SubprocessRunner.run("bd", ["kv", "clear", `claimed:${sessionId}`], { cwd });
+		await SubprocessRunner.run("bd", ["kv", "clear", `closed-this-session:${sessionId}`], { cwd });
+	};
+
+	const hasTrackableWork = async (cwd: string): Promise<boolean> => {
+		const result = await SubprocessRunner.run("bd", ["list"], { cwd });
+		if (result.code === 0) {
+			const counts = EventAdapter.parseBdCounts(result.stdout);
+			if (counts) return (counts.open + counts.inProgress) > 0;
+		}
+		return false;
+	};
+
+	const stripQuoted = (command: string): string => command.replace(/'[^']*'|"[^"]*"/g, "");
+	const isSpecialistsSubprocessCommand = (commandUnquoted: string): boolean =>
+		/\bspecialists\s+(run|resume|result|feed|stop|status)\b/.test(commandUnquoted);
+
+	const getClosedIssueIdFromCommand = (commandUnquoted: string): string | null => {
+		const match = commandUnquoted.match(/\bbd\s+close\s+(\S+)/);
+		const issueId = match?.[1]?.trim();
+		if (!issueId || issueId.startsWith("-")) return null;
+		return issueId;
+	};
+
+	const hasIssueMemoryAck = async (issueId: string, cwd: string): Promise<boolean> => {
+		const result = await SubprocessRunner.run("bd", ["kv", "get", `memory-acked:${issueId}`], { cwd });
+		return result.code === 0 && result.stdout.trim().length > 0;
+	};
+
+	const closeMemoryBlockReason = (issueId: string): string =>
+		`MEMORY_GATE_BLOCK issue=${issueId} run="bd remember '<insight>' && bd kv set 'memory-acked:${issueId}' 'saved:<key>'" or="bd kv set 'memory-acked:${issueId}' 'nothing novel:<reason>'" then="bd close ${issueId} --reason='<reason>'"`;
+
+	pi.on("session_start", async (_event, ctx) => {
+		cachedSessionId = ctx?.sessionManager?.getSessionId?.() ?? ctx?.sessionId ?? ctx?.session_id ?? cachedSessionId;
+		return undefined;
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
+		const sessionId = getSessionId(ctx);
+
+		if (EventAdapter.isMutatingFileTool(event)) {
+			const claim = await getActiveClaim(sessionId, cwd);
+			if (!claim) {
+				const hasWork = await hasTrackableWork(cwd);
+				if (hasWork) {
+					if (ctx.hasUI) {
+						ctx.ui.notify("Beads: Edit blocked. Claim an issue first.", "warning");
+					}
+					return {
+						block: true,
+						reason: `No active claim for session ${sessionId}.\n  bd update <id> --claim\n`,
+					};
+				}
+			}
+		}
+
+		if (isToolCallEventType("bash", event)) {
+			const command = event.input.command ?? "";
+			const commandUnquoted = stripQuoted(command);
+
+			if (isSpecialistsSubprocessCommand(commandUnquoted)) return undefined;
+
+			const closedIssueId = getClosedIssueIdFromCommand(commandUnquoted);
+			if (closedIssueId) {
+				const acked = await hasIssueMemoryAck(closedIssueId, cwd);
+				if (!acked) {
+					return {
+						block: true,
+						reason: closeMemoryBlockReason(closedIssueId),
+					};
+				}
+			}
+
+			if (/\bgit\s+commit\b/.test(commandUnquoted)) {
+				const claim = await getActiveClaim(sessionId, cwd);
+				if (claim) {
+					return {
+						block: true,
+						reason: `Active claim [${claim}] — close it first.\n  bd close ${claim}\n  (Pi workflow) publish/merge are external steps; do not rely on xtrm finish.\n`,
+					};
+				}
+			}
+		}
+
+		return undefined;
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (!isBashToolResult(event)) return undefined;
+
+		const command = event.input.command || "";
+		const sessionId = getSessionId(ctx);
+		const cwd = getCwd(ctx);
+
+		// Auto-claim on bd update --claim regardless of exit code.
+		if (/\bbd\s+update\b/.test(command) && /--claim\b/.test(command)) {
+			const issueMatch = command.match(/\bbd\s+update\s+(\S+)/);
+			if (issueMatch) {
+				const issueId = issueMatch[1];
+				await SubprocessRunner.run("bd", ["kv", "set", `claimed:${sessionId}`, issueId], { cwd });
+				memoryGateFired = false;
+				const claimNotice = `\n\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`. File edits are now unblocked.`;
+				return { content: [...event.content, { type: "text", text: claimNotice }] };
+			}
+		}
+
+		if (/\bbd\s+close\b/.test(command) && !event.isError) {
+			const closeMatch = command.match(/\bbd\s+close\s+(\S+)/);
+			const closedIssueId = closeMatch?.[1] ?? null;
+
+			if (closedIssueId) {
+				await SubprocessRunner.run("bd", ["kv", "set", `closed-this-session:${sessionId}`, closedIssueId], { cwd });
+				memoryGateFired = false;
+			}
+
+			const memoryGateText = closedIssueId
+				? `\n\n**Beads Memory Gate**: close-time memory ack verified for \`${closedIssueId}\` (\`memory-acked:${closedIssueId}\`).`
+				: `\n\n**Beads**: Work completed. Consider if this session produced insights worth persisting via \`bd remember\`.`;
+			return { content: [...event.content, { type: "text", text: memoryGateText }] };
+		}
+
+		return undefined;
+	});
+
+	// Memory gate: clean up session markers and check ack at agent_end/session_shutdown.
+	// Memory gate prompt was already injected into bd close tool_result context (silent, agent-visible only).
+	// No UI notification — parity with Claude Stop hook {additionalContext} pattern.
+	const triggerMemoryGateIfNeeded = async (ctx: any) => {
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return;
+		const sessionId = getSessionId(ctx);
+
+		const markerCheck = await SubprocessRunner.run("bd", ["kv", "get", `memory-gate-done:${sessionId}`], { cwd });
+		if (markerCheck.code === 0) {
+			await SubprocessRunner.run("bd", ["kv", "clear", `memory-gate-done:${sessionId}`], { cwd });
+			await clearSessionMarkers(sessionId, cwd);
+			memoryGateFired = false;
+			return;
+		}
+
+		if (memoryGateFired) return;
+
+		const closedIssueId = await getClosedThisSession(sessionId, cwd);
+		if (!closedIssueId) return;
+
+		const closeTimeAcked = await hasIssueMemoryAck(closedIssueId, cwd);
+		if (closeTimeAcked) {
+			await SubprocessRunner.run("bd", ["kv", "clear", `closed-this-session:${sessionId}`], { cwd });
+			memoryGateFired = false;
+			return;
+		}
+
+		memoryGateFired = true;
+		// No notify — memory gate was injected into bd close tool_result content (silent, agent-visible only).
+	};
+
+	pi.on("agent_end", async (_event, ctx) => {
+		await triggerMemoryGateIfNeeded(ctx);
+		return undefined;
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		await triggerMemoryGateIfNeeded(ctx);
+		return undefined;
+	});
+}

package/extensions/beads/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-beads",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: beads",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}

package/extensions/compact-header/index.ts

@@ -0,0 +1,69 @@
+/**
+ * oh-pi Compact Header — table-style startup info with dynamic column widths
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { VERSION } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    ctx.ui.setHeader((_tui, theme) => ({
+      render(width: number): string[] {
+        const d = (s: string) => theme.fg("dim", s);
+        const a = (s: string) => theme.fg("accent", s);
+
+        const cmds = pi.getCommands();
+        const prompts = cmds.filter(c => c.source === "prompt").map(c => `/${c.name}`).join("  ");
+        const skills = cmds.filter(c => c.source === "skill").map(c => c.name).join("  ");
+        const model = ctx.model ? `${ctx.model.id}` : "no model";
+        const thinking = pi.getThinkingLevel();
+        const provider = ctx.model?.provider ?? "";
+
+        const pad = (s: string, w: number) => s + " ".repeat(Math.max(0, w - visibleWidth(s)));
+        const t = (s: string) => truncateToWidth(s, width);
+        const sep = d(" │ ");
+
+        // Right two columns are fixed width
+        const rCol = [
+          [d("esc"), a("interrupt"),   d("S-tab"), a("thinking")],
+          [d("^C"),  a("clear/exit"),  d("^O"),    a("expand")],
+          [d("^P"),  a("model"),       d("^G"),    a("editor")],
+          [d("/"),   a("commands"),    d("^V"),    a("paste")],
+          [d("!"),   a("bash"),        d(""),      a("")],
+        ];
+        const k1w = 6, v1w = 13, k2w = 6, v2w = 9;
+        const rightW = k1w + v1w + 3 + k2w + v2w + 3; // 3 for each sep
+
+        // Left column gets remaining space
+        const leftW = Math.max(20, width - rightW);
+        const lk = 9; // label width
+
+        const lCol = [
+          [d("version"), a(`v${VERSION}  ${provider}`)],
+          [d("model"),   a(model)],
+          [d("think"),   a(thinking)],
+          [d(""),        d("")],
+          [d(""),        d("")],
+        ];
+
+        const lines: string[] = [""];
+        for (let i = 0; i < 5; i++) {
+          const [lk0, lv0] = lCol[i];
+          const [rk0, rv0, rk1, rv1] = rCol[i];
+          const left = truncateToWidth(pad(lk0, lk) + lv0, leftW);
+          const right = pad(rk0, k1w) + pad(rv0, v1w) + sep + pad(rk1, k2w) + rv1;
+          lines.push(t(pad(left, leftW) + sep + right));
+        }
+
+        if (prompts) lines.push(t(`${pad(d("prompts"), lk)}${a(prompts)}`));
+        if (skills) lines.push(t(`${pad(d("skills"), lk)}${a(skills)}`));
+        lines.push(d("─".repeat(width)));
+
+        return lines;
+      },
+      invalidate() {},
+    }));
+  });
+}

package/extensions/compact-header/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@xtrm/pi-compact-header",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: compact-header",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT"
+}