xtrm-tools 0.7.0 → 0.7.2

package/.xtrm/extensions/xtrm-ui/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "xtrm-ui",
+  "version": "1.0.0",
+  "description": "XTRM UI: pi-dex theme/header + custom XTRM footer",
+  "license": "MIT",
+  "pi": {
+    "extensions": ["./index.ts"],
+    "themes": ["./themes"]
+  }
+}

package/.xtrm/extensions/xtrm-ui/themes/pidex-dark.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "pidex-dark",
+  "vars": {
+    "accentBlue": "#b8d3ff",
+    "accentCyan": "#b8d3ff",
+    "accentTeal": "#c7d2e0",
+    "successGreen": "#9fd59f",
+    "errorRed": "#ff9a9a",
+    "warningAmber": "#d2b48c",
+    "surface": "#000000",
+    "surfaceAlt": "#111111",
+    "surfaceMuted": "#1a1a1a",
+    "surfaceUser": "#1f1f1f",
+    "surfaceCustom": "#161616",
+    "gray": "#a7a7a7",
+    "dimGray": "#8a8a8a",
+    "borderGray": "#666666",
+    "borderBright": "#9a9a9a"
+  },
+  "colors": {
+    "accent": "accentBlue",
+    "border": "borderGray",
+    "borderAccent": "borderBright",
+    "borderMuted": "borderGray",
+    "success": "successGreen",
+    "error": "errorRed",
+    "warning": "warningAmber",
+    "muted": "gray",
+    "dim": "dimGray",
+    "text": "",
+    "thinkingText": "gray",
+
+    "selectedBg": "surfaceMuted",
+    "userMessageBg": "surfaceUser",
+    "userMessageText": "",
+    "customMessageBg": "surfaceCustom",
+    "customMessageText": "",
+    "customMessageLabel": "accentBlue",
+    "toolPendingBg": "surfaceAlt",
+    "toolSuccessBg": "surfaceAlt",
+    "toolErrorBg": "surfaceAlt",
+    "toolTitle": "",
+    "toolOutput": "gray",
+
+    "mdHeading": "warningAmber",
+    "mdLink": "accentBlue",
+    "mdLinkUrl": "dimGray",
+    "mdCode": "accentCyan",
+    "mdCodeBlock": "gray",
+    "mdCodeBlockBorder": "borderGray",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "borderGray",
+    "mdHr": "borderGray",
+    "mdListBullet": "accentTeal",
+
+    "toolDiffAdded": "successGreen",
+    "toolDiffRemoved": "errorRed",
+    "toolDiffContext": "gray",
+
+    "syntaxComment": "#6b7280",
+    "syntaxKeyword": "#7aa2f7",
+    "syntaxFunction": "#c0caf5",
+    "syntaxVariable": "#a9b1d6",
+    "syntaxString": "#9ece6a",
+    "syntaxNumber": "#ff9e64",
+    "syntaxType": "#73daca",
+    "syntaxOperator": "#c0caf5",
+    "syntaxPunctuation": "#8f9bb3",
+
+    "thinkingOff": "borderGray",
+    "thinkingMinimal": "#707070",
+    "thinkingLow": "#7a7a7a",
+    "thinkingMedium": "#858585",
+    "thinkingHigh": "#8f8f8f",
+    "thinkingXhigh": "#999999",
+
+    "bashMode": "accentTeal"
+  },
+  "export": {
+    "pageBg": "#12161d",
+    "cardBg": "#171b22",
+    "infoBg": "#28230f"
+  }
+}

package/.xtrm/extensions/xtrm-ui/themes/pidex-light.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "pidex-light",
+  "vars": {
+    "accentBlue": "#44546a",
+    "accentCyan": "#5f6b7a",
+    "accentTeal": "#5f6b7a",
+    "successGreen": "#587558",
+    "errorRed": "#a85f5f",
+    "warningAmber": "#8e7348",
+    "surface": "#ffffff",
+    "surfaceAlt": "#f1f1f1",
+    "surfaceMuted": "#e6e6e6",
+    "surfaceUser": "#f0f0f0",
+    "surfaceCustom": "#f5f5f5",
+    "gray": "#5f5f5f",
+    "dimGray": "#7a7a7a",
+    "borderGray": "#b9b9b9",
+    "borderBright": "#9f9f9f"
+  },
+  "colors": {
+    "accent": "accentBlue",
+    "border": "borderGray",
+    "borderAccent": "borderBright",
+    "borderMuted": "borderGray",
+    "success": "successGreen",
+    "error": "errorRed",
+    "warning": "warningAmber",
+    "muted": "gray",
+    "dim": "dimGray",
+    "text": "",
+    "thinkingText": "gray",
+
+    "selectedBg": "surfaceMuted",
+    "userMessageBg": "surfaceUser",
+    "userMessageText": "",
+    "customMessageBg": "surfaceCustom",
+    "customMessageText": "",
+    "customMessageLabel": "accentBlue",
+    "toolPendingBg": "surfaceAlt",
+    "toolSuccessBg": "surfaceAlt",
+    "toolErrorBg": "surfaceAlt",
+    "toolTitle": "",
+    "toolOutput": "gray",
+
+    "mdHeading": "warningAmber",
+    "mdLink": "accentBlue",
+    "mdLinkUrl": "dimGray",
+    "mdCode": "accentCyan",
+    "mdCodeBlock": "gray",
+    "mdCodeBlockBorder": "borderGray",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "borderGray",
+    "mdHr": "borderGray",
+    "mdListBullet": "accentTeal",
+
+    "toolDiffAdded": "successGreen",
+    "toolDiffRemoved": "errorRed",
+    "toolDiffContext": "gray",
+
+    "syntaxComment": "#6b7280",
+    "syntaxKeyword": "#3569c8",
+    "syntaxFunction": "#3b4351",
+    "syntaxVariable": "#364152",
+    "syntaxString": "#3f7d3d",
+    "syntaxNumber": "#b06500",
+    "syntaxType": "#2c7a7b",
+    "syntaxOperator": "#3b4351",
+    "syntaxPunctuation": "#55606f",
+
+    "thinkingOff": "borderGray",
+    "thinkingMinimal": "#9d9d9d",
+    "thinkingLow": "#979797",
+    "thinkingMedium": "#919191",
+    "thinkingHigh": "#8b8b8b",
+    "thinkingXhigh": "#858585",
+
+    "bashMode": "accentTeal"
+  },
+  "export": {
+    "pageBg": "#f5f7fa",
+    "cardBg": "#ffffff",
+    "infoBg": "#fff5e6"
+  }
+}

package/{hooks → .xtrm/hooks}/README.md

@@ -26,7 +26,8 @@ The beads gate hooks integrate the `bd` (beads) issue tracker directly into Clau
 - **`beads-edit-gate.mjs`** (PreToolUse) — Blocks writes/edits without an active issue claim.
 - **`beads-commit-gate.mjs`** (PreToolUse) — Blocks commits with an unresolved session claim.
 - **`beads-stop-gate.mjs`** (Stop) — Blocks session stop while a claim remains open.
-- **`beads-close-memory-prompt.mjs`** (PostToolUse) — Prompts memory handoff after `bd close`.
+- **`beads-close-memory-gate.mjs`** (PreToolUse) — Blocks `bd close` until memory handoff is acknowledged per issue.
+- **`beads-memory-gate.mjs`** (Stop) — Fallback reminder if close-time memory acknowledgment is missing.
 
 ### Compaction & State Preservation (v2.1.18+)
 - **`beads-pre-compact.mjs`** (PreCompact) — Saves the currently `in_progress` beads state before Claude clears context.

package/{hooks → .xtrm/hooks}/beads-commit-gate.mjs

@@ -26,6 +26,10 @@ const command = input.tool_input?.command ?? '';
 // Strip quoted strings to avoid matching patterns inside --reason "..." or similar args
 const commandUnquoted = command.replace(/'[^']*'|"[^"]*"/g, '');
 
+if (/\bspecialists\s+(run|resume|result|feed|stop|status)\b/.test(commandUnquoted)) {
+  process.exit(0);
+}
+
 withSafeBdContext(() => {
   const ctx = resolveSessionContext(input);
   if (!ctx || !ctx.isBeadsProject) process.exit(0);

package/.xtrm/hooks/beads-memory-gate.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// beads-memory-gate — Claude Code Stop hook
+// At session end, checks if the session's claimed issue was closed.
+// If so, hard-blocks until the agent persists insights via `bd remember`.
+// Self-contained: queries claim kv + bd show directly (no PostToolUse dependency).
+// Exit 0: allow stop  |  Exit 2: block stop (stderr shown to Claude)
+//
+// Installed by: xtrm install
+
+import { execSync } from 'node:child_process';
+import { readHookInput } from './beads-gate-core.mjs';
+import { resolveCwd, resolveSessionId, isBeadsProject, clearSessionClaim } from './beads-gate-utils.mjs';
+import { memoryPromptMessage } from './beads-gate-messages.mjs';
+import { logEvent } from './xtrm-logger.mjs';
+
+const input = readHookInput();
+if (!input) process.exit(0);
+
+const cwd = resolveCwd(input);
+if (!cwd || !isBeadsProject(cwd)) process.exit(0);
+
+const sessionId = resolveSessionId(input);
+
+// ── Fast path: agent already acked the memory gate ──────────────────────────
+let memoryGateDone = false;
+try {
+  execSync(`bd kv get "memory-gate-done:${sessionId}"`, {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: 5000,
+  });
+  memoryGateDone = true;
+} catch { /* key not set → not done */ }
+
+if (memoryGateDone) {
+  // Clean up all session markers
+  for (const key of [`memory-gate-done:${sessionId}`, `claimed:${sessionId}`, `closed-this-session:${sessionId}`]) {
+    try { execSync(`bd kv clear "${key}"`, { cwd, stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }); } catch { /* ignore */ }
+  }
+  clearSessionClaim(sessionId, cwd);
+  logEvent({ cwd, runtime: 'claude', sessionId, layer: 'gate', kind: 'gate.memory.acked', outcome: 'allow' });
+  process.exit(0);
+}
+
+function getKvValue(key) {
+  try {
+    return execSync(`bd kv get "${key}"`, {
+      encoding: 'utf8',
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function inferIssueIdFromBranch() {
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      encoding: 'utf8',
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+    }).trim();
+    if (!branch || branch === 'HEAD') return null;
+
+    // Matches issue IDs in common branch naming schemes:
+    // feature/xtrm-86z0-foo, fix/xtrm-ab12, xtrm-86z0
+    const match = branch.match(/(?:^|\/)([a-z][a-z0-9]*-[a-z0-9]{3,})(?:-|$)/i);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ── Resolve candidate issue for session-end memory gate ───────────────────────
+// 1) claimed:<sessionId> (normal path)
+// 2) closed-this-session:<sessionId> (PostToolUse close marker)
+// 3) branch-derived issue ID (defense-in-depth when hooks were bypassed)
+const claimedIssueId =
+  getKvValue(`claimed:${sessionId}`) ??
+  getKvValue(`closed-this-session:${sessionId}`) ??
+  inferIssueIdFromBranch();
+
+if (!claimedIssueId) process.exit(0);
+
+// Query bd to check if the claimed issue is closed
+let issueStatus = null;
+try {
+  const raw = execSync(`bd show ${claimedIssueId} --json`, {
+    encoding: 'utf8',
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    timeout: 5000,
+  });
+  const parsed = JSON.parse(raw);
+  const issue = Array.isArray(parsed) ? parsed[0] : parsed;
+  issueStatus = issue?.status;
+} catch {
+  process.exit(0); // fail open
+}
+
+if (issueStatus !== 'closed') process.exit(0);
+
+// ── Issue was closed — hard-block until agent acks ──────────────────────────
+const memoryMessage = memoryPromptMessage(claimedIssueId, sessionId);
+logEvent({
+  cwd,
+  runtime: 'claude',
+  sessionId,
+  layer: 'gate',
+  kind: 'gate.memory.blocked',
+  outcome: 'block',
+  issueId: claimedIssueId,
+  message: memoryMessage,
+});
+process.stderr.write(memoryMessage + '\n');
+process.exit(2);

package/{plugins/xtrm-tools → .xtrm}/hooks/quality-check-env.mjs

@@ -17,10 +17,7 @@ try {
 const cwd = input.cwd ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
 
 // Only relevant in projects that have quality gates wired
-const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT ?? '';
-const hookPresent =
-  existsSync(path.join(pluginRoot, 'hooks', 'quality-check.cjs')) ||
-  existsSync(path.join(cwd, '.claude', 'hooks', 'quality-check.cjs'));
+const hookPresent = existsSync(path.resolve(cwd, '.xtrm', 'hooks', 'quality-check.cjs'));
 
 if (!hookPresent) process.exit(0);
 

package/.xtrm/hooks/statusline.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// statusline.mjs — Claude Code statusLine for xt claude sessions
+// Line 1: ~/path (branch *+↑)
+// Line 2: XX%/window (provider) model
+// Line 3: ◐ claim-title OR ○ N open
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join, basename, relative, dirname, isAbsolute } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+
+let ctx = {};
+try { ctx = JSON.parse(readFileSync(0, 'utf8')); } catch {}
+
+const cwd = ctx?.workspace?.current_dir ?? process.cwd();
+const cacheKey = createHash('md5').update(cwd).digest('hex').slice(0, 8);
+const CACHE_FILE = join(tmpdir(), `xtrm-sl-${cacheKey}.json`);
+const CACHE_TTL = 5000;
+
+function run(cmd) {
+  try { return execSync(cmd, { encoding: 'utf8', cwd, stdio: ['pipe', 'pipe', 'pipe'], timeout: 2000 }).trim(); } catch { return null; }
+}
+
+function getCached() {
+  try { const c = JSON.parse(readFileSync(CACHE_FILE, 'utf8')); if (Date.now() - c.ts < CACHE_TTL) return c.data; } catch {}
+  return null;
+}
+
+function setCache(data) { try { writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), data })); } catch {} }
+
+const R = '\x1b[0m', B = '\x1b[1m', B_ = '\x1b[22m', D = '\x1b[2m', I = '\x1b[3m', I_ = '\x1b[23m';
+
+function formatTokens(count) {
+  if (count < 1000) return count.toString();
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+  return `${Math.round(count / 1000000)}M`;
+}
+
+function getProvider(modelId) {
+  if (!modelId) return null;
+  if (modelId.includes('/')) return modelId.split('/')[0];
+  return null;
+}
+
+function getModelName(modelId) {
+  if (!modelId) return null;
+  if (modelId.includes('/')) return modelId.split('/')[1];
+  return modelId;
+}
+
+const pct = ctx?.context_window?.used_percentage;
+const windowSize = ctx?.context_window?.context_window_size ?? 200000;
+
+let data = getCached();
+if (!data) {
+  const repoRoot = run('git rev-parse --show-toplevel');
+  const gitCommonDir = run('git rev-parse --git-common-dir');
+  const mainRoot = (gitCommonDir && isAbsolute(gitCommonDir)) ? dirname(gitCommonDir) : (repoRoot || cwd);
+  let displayDir;
+  if (repoRoot) {
+    const rel = relative(repoRoot, cwd) || '.';
+    displayDir = rel === '.' ? basename(repoRoot) : `${basename(repoRoot)}/${rel}`;
+  } else {
+    displayDir = cwd.replace(process.env.HOME ?? '', '~');
+  }
+
+  let branch = null, gitFlags = '';
+  if (repoRoot) {
+    branch = run('git -c core.useBuiltinFSMonitor=false branch --show-current') || run('git rev-parse --short HEAD');
+    const porcelain = run('git -c core.useBuiltinFSMonitor=false --no-optional-locks status --porcelain') ?? '';
+    let modified = false, staged = false, deleted = false;
+    for (const l of porcelain.split('\n').filter(Boolean)) {
+      if (/^ M|^AM|^MM/.test(l)) modified = true;
+      if (/^A |^M /.test(l)) staged = true;
+      if (/^ D|^D /.test(l)) deleted = true;
+    }
+    gitFlags = (modified ? '*' : '') + (staged ? '+' : '') + (deleted ? '-' : '');
+    const ab = run('git -c core.useBuiltinFSMonitor=false --no-optional-locks rev-list --left-right --count @{upstream}...HEAD');
+    if (ab) {
+      const [behind, ahead] = ab.split(/\s+/).map(Number);
+      if (ahead > 0 && behind > 0) gitFlags += '↕';
+      else if (ahead > 0) gitFlags += '↑';
+      else if (behind > 0) gitFlags += '↓';
+    }
+  }
+
+  const modelId = ctx?.model?.id ?? null;
+  const modelDisplayName = ctx?.model?.display_name ?? null;
+  const provider = getProvider(modelId);
+  const modelName = modelDisplayName ?? getModelName(modelId) ?? null;
+
+  let claims = [], openCount = 0;
+  if (existsSync(join(cwd, '.beads')) || existsSync(join(mainRoot, '.beads'))) {
+    const inProgressRaw = run('bd list --status=in_progress') ?? '';
+    const ids = [...new Set(
+      [...inProgressRaw.matchAll(/^[◐]\s+([a-z][\w-]+)/gm)]
+        .map(m => m[1]).filter(id => id.includes('-'))
+    )];
+    if (ids.length === 1) {
+      try {
+        const raw = run(`bd show ${ids[0]} --json`);
+        const issue = raw ? JSON.parse(raw)?.[0] : null;
+        if (issue) claims.push({ id: ids[0], title: issue.title ?? null, status: issue.status ?? 'in_progress' });
+      } catch {}
+    } else if (ids.length > 1) {
+      claims = ids.map(id => ({ id, title: null, status: 'in_progress' }));
+    }
+    if (claims.length === 0) {
+      const m = run('bd list')?.match(/\((\d+)\s+open/);
+      if (m) openCount = parseInt(m[1], 10);
+    }
+  }
+
+  data = { displayDir, branch, gitFlags, provider, modelName, claims, openCount };
+  setCache(data);
+}
+
+const { displayDir, branch, gitFlags, provider, modelName, claims, openCount } = data;
+
+// Line 1: ~/path (branch *+↑)
+let line1 = B + displayDir + B_;
+if (branch) { const b = gitFlags ? `${branch} ${gitFlags}` : branch; line1 += ` ${D}(${b})${R}`; }
+
+// Line 2: XX%/window (provider) model
+const pctStr = pct != null ? `${pct.toFixed(1)}%` : '?';
+const ctxStr = `${pctStr}/${formatTokens(windowSize)}`;
+let modelStr = modelName ?? 'no-model';
+if (provider) modelStr = `(${provider}) ${modelStr}`;
+const line2 = `${D}${ctxStr}${R} ${D}${modelStr}${R}`;
+
+// Line 3: beads chip
+let line3;
+if (claims.length === 0) {
+  line3 = `○ ${openCount > 0 ? `${B}${openCount}${B_} open` : 'no open issues'}`;
+} else if (claims.length === 1) {
+  const { id, title, status } = claims[0];
+  const icon = status === 'blocked' ? '●' : status === 'in_progress' ? '◐' : '○';
+  const shortId = id.split('-').pop();
+  const cols = process.stdout.columns || 80;
+  const prefix = `${icon} ${shortId} `;
+  const max = Math.min(cols - prefix.length - 1, 40);
+  const t = title ? (title.length > max ? title.slice(0, max - 1) + '…' : title) : '';
+  line3 = `${prefix}${I}${t}${I_}`;
+} else {
+  const chips = claims.map(({ id, status }) => {
+    const icon = status === 'blocked' ? '●' : '◐';
+    return `${icon} ${id.split('-').pop()}`;
+  });
+  line3 = chips.join('  ');
+}
+
+process.stdout.write(`${line1}\n${line2}\n${line3}\n`);
+process.exit(0);

package/{plugins/xtrm-tools → .xtrm}/hooks/using-xtrm-reminder.mjs

@@ -5,18 +5,20 @@
 // Exit 0 in all paths (fail open).
 
 import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { resolve } from 'node:path';
 
 let input;
 try { input = JSON.parse(readFileSync(0, 'utf8')); } catch { process.exit(0); }
 
-const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
-if (!pluginRoot) process.exit(0);
+const cwd = input?.cwd ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
+
+const preferredSkillPath = resolve(cwd, '.xtrm', 'skills', 'default', 'using-xtrm', 'SKILL.md');
+
+if (!existsSync(preferredSkillPath)) process.exit(0);
 
-const skillPath = join(pluginRoot, 'skills', 'using-xtrm', 'SKILL.md');
 let content;
 try {
-  content = readFileSync(skillPath, 'utf8');
+  content = readFileSync(preferredSkillPath, 'utf8');
 } catch {
   process.exit(0);
 }
@@ -25,8 +27,7 @@ try {
 content = content.replace(/^---[\s\S]*?---\n/, '').trim();
 
 // Append .xtrm/memory.md if it exists in the project
-const cwd = input?.cwd ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-const memoryPath = join(cwd, '.xtrm', 'memory.md');
+const memoryPath = resolve(cwd, '.xtrm', 'memory.md');
 if (existsSync(memoryPath)) {
   try {
     const memory = readFileSync(memoryPath, 'utf8').trim();