xtrm-tools 0.5.11 → 0.5.13

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xtrm-cli",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "main": "./dist/index.js",
   "type": "module",

package/hooks/beads-gate-messages.mjs

@@ -57,12 +57,12 @@ export function stopBlockMessage(summary, claimed) {
 // ── Memory gate messages ─────────────────────────────────────────
 
 export function memoryPromptMessage(claimId) {
-  const claimLine = claimId ? `claim \`${claimId}\` was closed this session.\n` : '';
+  const claimLine = claimId ? `claim \`${claimId}\` was closed.\n` : '';
   return (
-    `🧠 Memory gate: ${claimLine}` +
-    'For each closed issue, worth persisting?\n' +
+    `\u25cf Memory gate: ${claimLine}` +
+    'Ask: "Would this be useful in 14 days on a fresh session?"\n' +
     '  YES → `bd remember "<insight>"`\n' +
     '  NO  → note "nothing to persist"\n' +
-    '  Then acknowledge: `touch .beads/.memory-gate-done`\n'
+    '  Then: `touch .beads/.memory-gate-done`\n'
   );
 }

package/hooks/gitnexus/gitnexus-hook.cjs

@@ -2,7 +2,7 @@
 /**
  * GitNexus Claude Code Hook — PostToolUse enrichment
  *
- * Fires AFTER Read/Grep/Glob/Bash/Serena tools complete.
+ * Fires AFTER Bash/Grep/Read/Glob/Serena tools complete.
  * Extracts patterns from both tool input AND output, runs
  * `gitnexus augment <pattern>`, and injects a [GitNexus: ...]
  * block into Claude's context — mirroring pi-gitnexus behavior.

package/hooks/hooks.json

@@ -12,6 +12,11 @@
             "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/beads-compact-restore.mjs",
             "timeout": 5000
           },
+          {
+            "type": "command",
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/quality-check-env.mjs",
+            "timeout": 5000
+          },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/serena-workflow-reminder.py"
@@ -104,17 +109,6 @@
           }
         ]
       }
-    ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/branch-state.mjs",
-            "timeout": 3000
-          }
-        ]
-      }
     ]
   }
 }

package/hooks/quality-check-env.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// SessionStart hook — verify quality gate environment is intact.
+// Checks for tsc, eslint, ruff so the agent knows early if enforcement
+// is silently degraded. Exits 0 always (informational only).
+
+import { readFileSync, existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+
+let input;
+try {
+  input = JSON.parse(readFileSync(0, 'utf8'));
+} catch {
+  process.exit(0);
+}
+
+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'));
+
+if (!hookPresent) process.exit(0);
+
+function which(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    // fall through to local node_modules probe
+  }
+  // Check node_modules/.bin/ walking up from cwd
+  let dir = cwd;
+  while (true) {
+    if (existsSync(path.join(dir, 'node_modules', '.bin', cmd))) return true;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+
+const warnings = [];
+
+// CLAUDE_PROJECT_DIR check
+if (!process.env.CLAUDE_PROJECT_DIR) {
+  warnings.push('CLAUDE_PROJECT_DIR is not set — quality gate may target wrong directory');
+}
+
+// TypeScript project checks
+const hasTsConfig = existsSync(path.join(cwd, 'tsconfig.json')) ||
+  existsSync(path.join(cwd, 'cli', 'tsconfig.json'));
+
+if (hasTsConfig) {
+  if (!which('tsc')) warnings.push('tsc not found — TypeScript compilation check will be skipped');
+  const hasEslintConfig = ['eslint.config.js', 'eslint.config.mjs', '.eslintrc.js', '.eslintrc.json', '.eslintrc.yml']
+    .some(f => existsSync(path.join(cwd, f)));
+  if (hasEslintConfig && !which('eslint')) warnings.push('eslint not found — ESLint check will be skipped');
+}
+
+// Python project checks
+const hasPyFiles = existsSync(path.join(cwd, 'pyproject.toml')) ||
+  existsSync(path.join(cwd, 'setup.py')) ||
+  existsSync(path.join(cwd, 'requirements.txt'));
+
+if (hasPyFiles) {
+  if (!which('ruff')) warnings.push('ruff not found — Python lint check will be skipped');
+}
+
+if (warnings.length === 0) process.exit(0);
+
+const msg = `⚠️ Quality gate environment issue(s) detected:\n${warnings.map(w => `  • ${w}`).join('\n')}\nFix these to ensure quality gates enforce correctly.`;
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: { additionalSystemPrompt: msg },
+}));
+process.exit(0);

package/hooks/quality-check.cjs

@@ -447,7 +447,7 @@ class QualityChecker {
     if (/\.(ts|tsx)$/.test(filePath)) {
       return 'typescript';
     }
-    if (/\.(js|jsx)$/.test(filePath)) {
+    if (/\.(js|jsx|cjs|mjs)$/.test(filePath)) {
       return 'javascript';
     }
     return 'unknown';
@@ -537,7 +537,7 @@ class QualityChecker {
     const resolved = path.resolve(dir, importPath);
 
     // Try common extensions
-    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.cjs', '.mjs'];
     for (const ext of extensions) {
       const fullPath = resolved + ext;
       if (require('fs').existsSync(fullPath)) {
@@ -565,8 +565,8 @@ class QualityChecker {
       return;
     }
 
-    // Skip TypeScript checking for JavaScript files in hook directories
-    if (this.filePath.endsWith('.js') && this.filePath.includes('.claude/hooks/')) {
+    // Skip TypeScript checking for JavaScript/CJS/MJS files in hook directories
+    if (/\.(js|cjs|mjs)$/.test(this.filePath) && this.filePath.includes('.claude/hooks/')) {
       log.debug('Skipping TypeScript check for JavaScript hook file');
       return;
     }
@@ -865,7 +865,7 @@ class QualityChecker {
       const debuggerRule = config._fileConfig.rules?.debugger || {};
       if (debuggerRule.enabled !== false) {
         lines.forEach((line, index) => {
-          if (/\bdebugger\b/.test(line)) {
+          if (/^\s*debugger\s*;/.test(line)) {
             const severity = debuggerRule.severity || 'error';
             const message =
               debuggerRule.message || 'Remove debugger statements before committing';
@@ -1111,7 +1111,7 @@ async function fileExists(filePath) {
  * @returns {boolean} True if source file
  */
 function isSourceFile(filePath) {
-  return /\.(ts|tsx|js|jsx)$/.test(filePath);
+  return /\.(ts|tsx|js|jsx|cjs|mjs)$/.test(filePath);
 }
 
 /**

package/hooks/statusline.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// statusline.mjs — Claude Code statusLine command for xt claude worktree sessions
+// Two lines:
+//   Line 1 (plain):   XTRM  ⎇ <branch>
+//   Line 2 (colored): ◐ <claim title in italics>  OR  ○ N open
+// State file: .xtrm/statusline-claim (written by beads-claim-sync.mjs)
+// Results cached 5s in /tmp to avoid hammering bd on every render.
+
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+
+const cwd = 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 {}
+}
+
+// ANSI
+const R          = '\x1b[0m';
+const BOLD       = '\x1b[1m';
+const BOLD_OFF   = '\x1b[22m';
+const ITALIC     = '\x1b[3m';
+const ITALIC_OFF = '\x1b[23m';
+const FG_WHITE   = '\x1b[38;5;15m';
+const FG_ACCENT  = '\x1b[38;5;75m';
+const FG_MUTED   = '\x1b[38;5;245m';
+const BG_CLAIMED = '\x1b[48;5;17m';
+const BG_IDLE    = '\x1b[48;5;238m';
+
+// Data
+let data = getCached();
+if (!data) {
+  const branch = run('git branch --show-current');
+  let claimTitle = null;
+  let openCount = 0;
+
+  const hasBeads = existsSync(join(cwd, '.beads'));
+  if (hasBeads) {
+    const claimFile = join(cwd, '.xtrm', 'statusline-claim');
+    let claimId = null;
+    if (existsSync(claimFile)) {
+      claimId = readFileSync(claimFile, 'utf8').trim() || null;
+    }
+
+    if (claimId) {
+      try {
+        const raw = run(`bd show ${claimId} --json`);
+        if (raw) {
+          const parsed = JSON.parse(raw);
+          claimTitle = parsed?.[0]?.title ?? null;
+        }
+      } catch {}
+    }
+
+    if (!claimTitle) {
+      const listOut = run('bd list');
+      const m = listOut?.match(/\((\d+)\s+open/);
+      if (m) openCount = parseInt(m[1], 10);
+    }
+  }
+
+  data = { branch, claimTitle, openCount };
+  setCache(data);
+}
+
+// Render
+const { branch, claimTitle, openCount } = data;
+const cols = process.stdout.columns || 80;
+
+const brand = `${BOLD}${FG_ACCENT}XTRM${BOLD_OFF}${R}`;
+const branchStr = branch ? `${FG_MUTED}⎇ ${branch}${R}` : '';
+const line1 = [brand, branchStr].filter(Boolean).join('  ');
+
+function padded(text, bg) {
+  const visible = text.replace(/\x1b\[[0-9;]*m/g, '');
+  const pad = Math.max(0, cols - visible.length);
+  return `${bg}${FG_WHITE}${text}${' '.repeat(pad)}${R}`;
+}
+
+let line2;
+if (claimTitle) {
+  const maxLen = cols - 4;
+  const title = claimTitle.length > maxLen ? claimTitle.slice(0, maxLen - 1) + '\u2026' : claimTitle;
+  line2 = padded(` \u25d0 ${ITALIC}${title}${ITALIC_OFF}`, BG_CLAIMED);
+} else {
+  const idle = openCount > 0 ? `\u25cb ${openCount} open` : '\u25cb no open issues';
+  line2 = padded(` ${idle}`, BG_IDLE);
+}
+
+process.stdout.write(line1 + '\n' + line2 + '\n');
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xtrm-tools",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "license": "MIT",
   "type": "module",

package/hooks/branch-state.mjs

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-// branch-state.mjs — UserPromptSubmit hook
-// Re-injects current git branch and active beads claim at each prompt.
-// Keeps the agent oriented after /compact or long sessions.
-// Output: { hookSpecificOutput: { additionalSystemPrompt } }
-
-import { execSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-
-function readInput() {
-  try { return JSON.parse(readFileSync(0, 'utf-8')); } catch { return null; }
-}
-
-function getBranch(cwd) {
-  try {
-    return execSync('git branch --show-current', {
-      encoding: 'utf8', cwd,
-      stdio: ['pipe', 'pipe', 'pipe'], timeout: 2000,
-    }).trim() || null;
-  } catch { return null; }
-}
-
-try {
-  const input = readInput();
-  if (!input) process.exit(0);
-
-  const cwd = input.cwd || process.cwd();
-  const branch = getBranch(cwd);
-
-  if (!branch) process.exit(0);
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { additionalSystemPrompt: `[Context: branch=${branch}]` },
-  }));
-  process.stdout.write('\n');
-  process.exit(0);
-} catch {
-  process.exit(0);
-}