xtrm-tools 0.7.0 → 0.7.2

package/cli/package.json

@@ -1,16 +1,18 @@
 {
   "name": "xtrm-cli",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "main": "./dist/index.js",
   "type": "module",
   "bin": {
     "xtrm": "dist/index.cjs",
-    "xt": "dist/index.cjs"
+    "xt": "dist/index.cjs",
+    "ghgrep": "scripts/ghgrep.mjs"
   },
   "files": [
     "dist",
-    "config"
+    "config",
+    "scripts/ghgrep.mjs"
   ],
   "scripts": {
     "prebuild": "node -e \"if(process.cwd().includes('/.xtrm/worktrees/')){console.error('ERROR: Do not run npm run build from a worktree — dist paths will be contaminated.\\nRun from the main repo: cd <repo-root>/cli && npm run build');process.exit(1)}\"",
@@ -40,6 +42,7 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.3.0",
+    "fast-check": "^4.6.0",
     "tdd-guard-vitest": "^0.1.6",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xtrm-tools",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "license": "MIT",
   "type": "module",
@@ -10,23 +10,26 @@
   ],
   "bin": {
     "xtrm": "cli/dist/index.cjs",
-    "xt": "cli/dist/index.cjs"
+    "xt": "cli/dist/index.cjs",
+    "ghgrep": "scripts/ghgrep.mjs"
   },
   "files": [
     "README.md",
     "CHANGELOG.md",
     "cli/dist",
     "cli/package.json",
-    "config",
-    "hooks",
-    "skills",
-    "project-skills",
-    ".claude-plugin",
-    "plugins",
+    "scripts/ghgrep.mjs",
+    ".xtrm/config",
+    ".xtrm/hooks",
+    ".xtrm/extensions",
+    ".xtrm/registry.json",
     "!**/__pycache__/**",
     "!**/*.pyc",
-    "!project-skills/service-skills-set/.claude/skills/using-service-skills/scripts/test_*.py",
-    "!skills/documenting/tests/**"
+    "!.xtrm/hooks/tsconfig-cache.json",
+    "!.xtrm/config/pi/extensions/**/.pi/**",
+    "!.xtrm/extensions/**/.pi/**",
+    "!.xtrm/**/test_*.py",
+    "!.xtrm/**/tests/**"
   ],
   "publishConfig": {
     "access": "public"
@@ -51,10 +54,9 @@
     "lint": "echo 'No linting configured'",
     "test": "npm test --workspace cli",
     "version": "npm run sync:cli-version && git add cli/package.json",
-    "prepack": "node scripts/prepack-plugin.mjs",
-    "postpack": "node scripts/postpack-plugin.mjs",
     "prepublishOnly": "npm run sync:cli-version && npm run build",
-    "release": "npm publish --tag latest"
+    "release": "npm publish --tag latest",
+    "gen-registry": "node scripts/gen-registry.mjs"
   },
   "engines": {
     "node": ">=20.0.0"

package/scripts/ghgrep.mjs

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+
+const ENDPOINT = 'https://mcp.grep.app';
+const DEFAULT_LIMIT = 10;
+
+function printUsage() {
+  console.log(`ghgrep <query> [options]
+
+Options:
+  --lang <langs>       Filter by language (comma-separated): TypeScript,TSX,Python
+  --repo <repo>        Filter by repo: facebook/react
+  --path <path>        Filter by file path pattern
+  --regexp             Treat query as regex (auto-prefixes (?s) for multiline)
+  --case               Case-sensitive match
+  --words              Match whole words only
+  --json               Raw JSON output
+  --limit <n>          Max results (default: 10)
+  -h, --help           Show help
+`);
+}
+
+function parseCliArgs(argv) {
+  const options = {
+    caseSensitive: false,
+    json: false,
+    languages: [],
+    limit: DEFAULT_LIMIT,
+    path: undefined,
+    regexp: false,
+    repo: undefined,
+    wholeWords: false,
+  };
+
+  const queryParts = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '-h' || arg === '--help') {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === '--regexp') {
+      options.regexp = true;
+      continue;
+    }
+
+    if (arg === '--case') {
+      options.caseSensitive = true;
+      continue;
+    }
+
+    if (arg === '--words') {
+      options.wholeWords = true;
+      continue;
+    }
+
+    if (arg === '--lang' || arg === '--repo' || arg === '--path' || arg === '--limit') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+
+      if (arg === '--lang') {
+        options.languages = value
+          .split(',')
+          .map((item) => item.trim())
+          .filter(Boolean);
+      }
+
+      if (arg === '--repo') {
+        options.repo = value;
+      }
+
+      if (arg === '--path') {
+        options.path = value;
+      }
+
+      if (arg === '--limit') {
+        const parsedLimit = Number.parseInt(value, 10);
+        if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
+          throw new Error(`Invalid --limit value: ${value}`);
+        }
+        options.limit = parsedLimit;
+      }
+
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+
+    queryParts.push(arg);
+  }
+
+  return {
+    options,
+    query: queryParts.join(' ').trim(),
+  };
+}
+
+function parseSseChunk(chunk, state, events) {
+  state.buffer += chunk;
+  const lines = state.buffer.split(/\r?\n/);
+  state.buffer = lines.pop() ?? '';
+
+  for (const line of lines) {
+    if (line === '') {
+      if (state.eventData.length > 0) {
+        const payload = state.eventData.join('\n').trim();
+        if (payload && payload !== '[DONE]') {
+          events.push(payload);
+        }
+      }
+      state.eventData = [];
+      continue;
+    }
+
+    if (line.startsWith('data:')) {
+      state.eventData.push(line.slice(5).trimStart());
+    }
+  }
+}
+
+async function parseMcpResponse(response) {
+  const contentType = response.headers.get('content-type') ?? '';
+
+  if (contentType.includes('application/json')) {
+    return [await response.json()];
+  }
+
+  if (!contentType.includes('text/event-stream')) {
+    const body = await response.text();
+    throw new Error(`Unexpected response type: ${contentType || 'unknown'}\n${body}`);
+  }
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error('Response stream is empty');
+  }
+
+  const decoder = new TextDecoder();
+  const events = [];
+  const state = { buffer: '', eventData: [] };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    parseSseChunk(decoder.decode(value, { stream: true }), state, events);
+  }
+
+  const trailingChunk = decoder.decode();
+  if (trailingChunk) {
+    parseSseChunk(trailingChunk, state, events);
+  }
+
+  if (state.eventData.length > 0) {
+    const payload = state.eventData.join('\n').trim();
+    if (payload && payload !== '[DONE]') {
+      events.push(payload);
+    }
+  }
+
+  return events.map((event) => {
+    try {
+      return JSON.parse(event);
+    } catch {
+      return { raw: event };
+    }
+  });
+}
+
+async function callMcp(method, params) {
+  const response = await fetch(ENDPOINT, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json, text/event-stream',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      id: Date.now(),
+      jsonrpc: '2.0',
+      method,
+      params,
+    }),
+  });
+
+  const payloads = await parseMcpResponse(response);
+  if (!response.ok) {
+    throw new Error(`MCP request failed: ${response.status} ${response.statusText}`);
+  }
+
+  return payloads;
+}
+
+function parseSnippetSections(snippetsText) {
+  const sections = snippetsText.split(/--- Snippet \d+ \(Line (\d+)\) ---\n/g);
+  const snippets = [];
+
+  for (let index = 1; index < sections.length; index += 2) {
+    const line = Number.parseInt(sections[index], 10);
+    const code = (sections[index + 1] ?? '').trimEnd();
+    snippets.push({
+      code,
+      line: Number.isFinite(line) ? line : undefined,
+    });
+  }
+
+  return snippets;
+}
+
+function parseResultBlock(text) {
+  const match = text.match(
+    /^Repository:\s*(.+)\nPath:\s*(.+)\nURL:\s*(.+)\nLicense:\s*(.+)\n\nSnippets:\n([\s\S]*)$/,
+  );
+
+  if (!match) {
+    return null;
+  }
+
+  return {
+    license: match[4].trim(),
+    path: match[2].trim(),
+    repo: match[1].trim(),
+    snippets: parseSnippetSections(match[5]),
+    url: match[3].trim(),
+  };
+}
+
+function formatEntries(entries) {
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    const firstSnippetLine = entry.snippets[0]?.line;
+    const location = firstSnippetLine ? `${entry.repo}/${entry.path}:${firstSnippetLine}` : `${entry.repo}/${entry.path}`;
+
+    console.log(`${index + 1}. ${location}`);
+    console.log(`   ${entry.url}`);
+    console.log(`   License: ${entry.license}`);
+
+    for (const snippet of entry.snippets) {
+      const lineLabel = snippet.line ? `Line ${snippet.line}` : 'Snippet';
+      console.log(`\n   --- ${lineLabel} ---`);
+      const snippetLines = snippet.code.split('\n');
+      for (const snippetLine of snippetLines) {
+        console.log(`   ${snippetLine}`);
+      }
+    }
+
+    if (index < entries.length - 1) {
+      console.log('\n' + '-'.repeat(80) + '\n');
+    }
+  }
+}
+
+function getTextContent(resultPayload) {
+  const content = resultPayload?.result?.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  return content
+    .filter((item) => item?.type === 'text' && typeof item.text === 'string')
+    .map((item) => item.text);
+}
+
+async function run() {
+  const { options, query } = parseCliArgs(process.argv.slice(2));
+
+  if (options.help || !query) {
+    printUsage();
+    process.exit(options.help ? 0 : 1);
+  }
+
+  const requestArguments = {
+    query: options.regexp && !query.startsWith('(?s)') ? `(?s)${query}` : query,
+  };
+
+  if (options.caseSensitive) {
+    requestArguments.matchCase = true;
+  }
+
+  if (options.wholeWords) {
+    requestArguments.matchWholeWords = true;
+  }
+
+  if (options.regexp) {
+    requestArguments.useRegexp = true;
+  }
+
+  if (options.repo) {
+    requestArguments.repo = options.repo;
+  }
+
+  if (options.path) {
+    requestArguments.path = options.path;
+  }
+
+  if (options.languages.length > 0) {
+    requestArguments.language = options.languages;
+  }
+
+  const payloads = await callMcp('tools/call', {
+    arguments: requestArguments,
+    name: 'searchGitHub',
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(payloads, null, 2));
+    return;
+  }
+
+  const resultPayload = payloads.find((payload) => payload?.result || payload?.error) ?? payloads[0];
+
+  if (resultPayload?.error) {
+    throw new Error(resultPayload.error.message ?? JSON.stringify(resultPayload.error));
+  }
+
+  const textBlocks = getTextContent(resultPayload);
+  const isError = resultPayload?.result?.isError === true;
+
+  if (isError) {
+    throw new Error(textBlocks.join('\n\n') || 'searchGitHub returned an error');
+  }
+
+  const parsedEntries = textBlocks
+    .map((block) => parseResultBlock(block))
+    .filter((entry) => entry !== null)
+    .slice(0, options.limit);
+
+  if (parsedEntries.length > 0) {
+    formatEntries(parsedEntries);
+    return;
+  }
+
+  const plainText = textBlocks.join('\n\n').trim();
+  if (!plainText) {
+    console.log('No results.');
+    return;
+  }
+
+  console.log(plainText);
+}
+
+run().catch((error) => {
+  console.error(`ghgrep error: ${error.message}`);
+  process.exit(1);
+});

package/.claude-plugin/marketplace.json

@@ -1,19 +0,0 @@
-{
-  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
-  "name": "xtrm-tools",
-  "description": "xtrm-tools: workflow enforcement hooks, skills, and MCP servers for Claude Code",
-  "owner": {
-    "name": "jaggers"
-  },
-  "plugins": [
-    {
-      "name": "xtrm-tools",
-      "description": "Workflow enforcement hooks (main-guard, beads gates), skills, and MCP server wiring for Claude Code",
-      "author": {
-        "name": "jaggers"
-      },
-      "source": "./plugins/xtrm-tools",
-      "category": "productivity"
-    }
-  ]
-}

package/.claude-plugin/plugin.json

@@ -1,9 +0,0 @@
-{
-  "name": "xtrm-tools",
-  "version": "0.7.0",
-  "description": "xtrm-tools: dual-runtime workflow enforcement (Claude Code + Pi) — hooks, extensions, skills, and MCP servers",
-  "author": {
-    "name": "jaggers"
-  },
-  "mcpServers": "./.mcp.json"
-}

package/config/hooks.json

@@ -1,83 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "script": "using-xtrm-reminder.mjs"
-      },
-      {
-        "script": "beads-compact-restore.mjs",
-        "timeout": 5000
-      },
-      {
-        "script": "quality-check-env.mjs",
-        "timeout": 5000
-      },
-      {
-        "script": "xtrm-session-logger.mjs",
-        "timeout": 3000
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol",
-        "script": "worktree-boundary.mjs",
-        "timeout": 2000
-      },
-      {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol",
-        "script": "beads-edit-gate.mjs",
-        "timeout": 5000
-      },
-      {
-        "matcher": "Bash",
-        "script": "beads-commit-gate.mjs",
-        "timeout": 5000
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Bash|execute_shell_command|bash",
-        "script": "beads-claim-sync.mjs",
-        "timeout": 5000
-      },
-      {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol",
-        "script": "quality-check.cjs",
-        "timeout": 30000
-      },
-      {
-        "matcher": "Edit|Write|MultiEdit|NotebookEdit|mcp__serena__rename_symbol|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol",
-        "script": "quality-check.py",
-        "timeout": 30000
-      },
-      {
-        "matcher": "Bash|Grep|Read|Glob|mcp__serena__find_symbol|mcp__serena__get_symbols_overview|mcp__serena__search_for_pattern|mcp__serena__find_referencing_symbols|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol|mcp__serena__rename_symbol",
-        "script": "gitnexus/gitnexus-hook.cjs",
-        "timeout": 10000
-      },
-      {
-        "script": "xtrm-tool-logger.mjs",
-        "timeout": 3000
-      }
-    ],
-    "Stop": [
-      {
-        "script": "beads-stop-gate.mjs",
-        "timeout": 5000
-      },
-      {
-        "script": "beads-memory-gate.mjs",
-        "timeout": 8000
-      }
-    ],
-    "PreCompact": [
-      {
-        "script": "beads-compact-save.mjs",
-        "timeout": 5000
-      }
-    ]
-  },
-  "statusLine": {
-    "script": "statusline.mjs"
-  }
-}

package/config/settings.json

@@ -1,70 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "mcp__serena__list_memories",
-      "mcp__serena__read_memory",
-      "mcp__serena__get_symbols_overview",
-      "mcp__serena__find_symbol",
-      "mcp__serena__replace_symbol_body",
-      "Bash(python -m py_compile:*)",
-      "Bash(tree:*)",
-      "Bash(podman exec:*)",
-      "mcp__serena__list_dir",
-      "mcp__yfinance-market-intelligence__get_volatility_metrics",
-      "mcp__yfinance-market-intelligence__get_amt_snapshot",
-      "mcp__yfinance-market-intelligence__get_market_overview",
-      "Skill(scan-context)",
-      "mcp__gmail__search_emails",
-      "mcp__gmail__read_email",
-      "mcp__gmail__batch_modify_emails",
-      "mcp__gmail__list_email_labels",
-      "mcp__plugin_serena_serena__get_symbols_overview"
-    ],
-    "defaultMode": "default"
-  },
-  "model": "sonnet",
-  "skillSuggestions": {
-    "enabled": true
-  },
-  "hooks": {
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 \"$HOME/.claude/skills/documenting/scripts/drift_detector.py\" hook",
-            "timeout": 5
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "Grep|Glob|Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"$HOME/.claude/hooks/gitnexus/gitnexus-hook.cjs\"",
-            "timeout": 8000,
-            "statusMessage": "Enriching with GitNexus graph context..."
-          }
-        ]
-      }
-    ]
-  },
-  "enabledPlugins": {
-    "pyright-lsp@claude-plugins-official": true,
-    "serena@claude-plugins-official": true,
-    "superpowers@superpowers-marketplace": true,
-    "convosync@convocli-marketplace": true,
-    "commit-commands@claude-plugins-official": true,
-    "context7@claude-plugins-official": true,
-    "github@claude-plugins-official": true,
-    "hookify@claude-plugins-official": true,
-    "agent-sdk-dev@claude-plugins-official": true,
-    "feature-dev@claude-plugins-official": true,
-    "plugin-dev@claude-plugins-official": true,
-    "claude-mem@thedotmack": true,
-    "code-simplifier@claude-plugins-official": true
-  }
-}