xtrm-tools 0.7.4 → 0.7.7

package/.xtrm/ext-src/pi-serena-compact/index.ts

@@ -0,0 +1,121 @@
+import type { ExtensionAPI, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+
+// Serena/GitNexus MCP tool names that produce verbose output
+const COMPACT_TOOLS = new Set([
+  // Serena symbol operations
+  "find_symbol",
+  "find_referencing_symbols", 
+  "get_symbols_overview",
+  "jet_brains_find_symbol",
+  "jet_brains_find_referencing_symbols",
+  "jet_brains_get_symbols_overview",
+  "jet_brains_type_hierarchy",
+  
+  // Serena file operations
+  "read_file",
+  "create_text_file",
+  "replace_content",
+  "replace_lines",
+  "delete_lines",
+  "insert_at_line",
+  
+  // Serena search/navigation
+  "search_for_pattern",
+  "list_dir",
+  "find_file",
+  
+  // Serena symbol editing
+  "replace_symbol_body",
+  "insert_after_symbol",
+  "insert_before_symbol",
+  "rename_symbol",
+  
+  // GitNexus
+  "gitnexus_query",
+  "gitnexus_context",
+  "gitnexus_impact",
+  "gitnexus_detect_changes",
+  "gitnexus_list_repos",
+  
+  // Serena memory
+  "read_memory",
+  "write_memory",
+  "list_memories",
+  
+  // Other verbose tools
+  "execute_shell_command",
+  "structured_return",
+]);
+
+// Tools that should show more output even when compacted
+const PRESERVE_OUTPUT_TOOLS = new Set([
+  "read_file",
+  "read_memory",
+  "execute_shell_command",
+  "structured_return",
+]);
+
+function isSerenaTool(toolName: string): boolean {
+  return COMPACT_TOOLS.has(toolName);
+}
+
+function getTextContent(content: Array<{ type: string; text?: string }>): string {
+  const item = content.find((c) => c.type === "text");
+  return item?.text ?? "";
+}
+
+function truncateLines(text: string, maxLines: number, maxLineLen = 180): string {
+  const lines = text.split("\n");
+  const truncated = lines.map(line => 
+    line.length > maxLineLen ? line.slice(0, maxLineLen) + "…" : line
+  );
+  
+  if (truncated.length <= maxLines) return truncated.join("\n");
+  return truncated.slice(0, maxLines).join("\n") + `\n… +${truncated.length - maxLines} more lines`;
+}
+
+function compactResult(
+  toolName: string,
+  content: Array<{ type: string; text?: string }>,
+  maxLines: number = 6,
+): Array<{ type: string; text: string }> {
+  const textContent = getTextContent(content);
+  
+  if (!textContent) {
+    return [{ type: "text", text: "✓ No output" }];
+  }
+  
+  // For certain tools, show more output
+  const effectiveMaxLines = PRESERVE_OUTPUT_TOOLS.has(toolName) ? 12 : maxLines;
+  
+  const compacted = truncateLines(textContent, effectiveMaxLines, 180);
+  
+  return [{ type: "text", text: compacted }];
+}
+
+export default function serenaCompactExtension(pi: ExtensionAPI): void {
+  let toolsExpanded = false;
+
+  // Track tools expanded state
+  pi.on("session_start", async (_event, ctx) => {
+    toolsExpanded = ctx.ui.getToolsExpanded();
+  });
+
+  pi.on("session_switch", async (_event, ctx) => {
+    toolsExpanded = ctx.ui.getToolsExpanded();
+  });
+
+  // Compact Serena tool results
+  pi.on("tool_result", async (event: ToolResultEvent) => {
+    // Only handle Serena/MCP tools
+    if (!isSerenaTool(event.toolName)) return undefined;
+    
+    // If tools are expanded, don't compact
+    if (toolsExpanded) return undefined;
+    
+    // Compact the content
+    const compacted = compactResult(event.toolName, event.content, 6);
+    
+    return { content: compacted };
+  });
+}

package/.xtrm/ext-src/pi-serena-compact/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "pi-serena-compact",
+  "version": "1.0.0",
+  "description": "Compact output for Serena MCP tools in Pi",
+  "keywords": ["pi", "pi-extension", "serena", "mcp"],
+  "license": "MIT",
+  "type": "module",
+  "main": "index.ts",
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "^0.56.0",
+    "@mariozechner/pi-tui": "^0.56.0"
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  }
+}

package/.xtrm/ext-src/quality-gates/index.ts

@@ -0,0 +1,66 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter } from "@xtrm/pi-core";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+function resolveQualityHook(cwd: string, ext: string): { runner: string; scriptPath: string } | null {
+	if ([".ts", ".tsx", ".js", ".jsx", ".cjs", ".mjs"].includes(ext)) {
+		const scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.cjs");
+		return { runner: "node", scriptPath };
+	}
+	if (ext === ".py") {
+		const scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.py");
+		return { runner: "python3", scriptPath };
+	}
+	return null;
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("tool_result", async (event, ctx) => {
+		if (!EventAdapter.isMutatingFileTool(event)) return undefined;
+
+		const cwd = ctx.cwd || process.cwd();
+		const filePath = EventAdapter.extractPathFromToolInput(event, cwd);
+		if (!filePath) return undefined;
+
+		const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+		const ext = path.extname(fullPath);
+		const resolved = resolveQualityHook(cwd, ext);
+		if (!resolved) return undefined;
+		if (!fs.existsSync(resolved.scriptPath)) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: event.toolName,
+			tool_input: event.input,
+			cwd,
+		});
+
+		const result = await SubprocessRunner.run(resolved.runner, [resolved.scriptPath], {
+			cwd,
+			input: hookInput,
+			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
+			timeoutMs: 30000,
+		});
+
+		if (result.code === 0) {
+			const details = (result.stdout || result.stderr || "").trim();
+			if (!details) return undefined;
+			return {
+				content: [...event.content, { type: "text", text: `\n\n**Quality Gate**: ${details}` }],
+			};
+		}
+
+		if (result.code === 2) {
+			const details = (result.stderr || result.stdout || "Unknown error").trim();
+			if (ctx.hasUI) {
+				ctx.ui.notify(`Quality Gate failed for ${path.basename(fullPath)}`, "error");
+			}
+			return {
+				isError: true,
+				content: [...event.content, { type: "text", text: `\n\n**Quality Gate FAILED**:\n${details}` }],
+			};
+		}
+
+		return undefined;
+	});
+}

package/.xtrm/ext-src/quality-gates/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@xtrm/pi-quality-gates",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: quality-gates",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT",
+  "dependencies": {
+    "@xtrm/pi-core": "^1.0.0"
+  }
+}

package/.xtrm/ext-src/service-skills/index.ts

@@ -0,0 +1,108 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner } from "@xtrm/pi-core";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const SERVICE_REGISTRY_FILES = [
+	"service-registry.json",
+	path.join(".claude", "skills", "service-registry.json"),
+];
+
+const GLOBAL_SKILL_ROOTS = [
+	path.join(process.env.HOME || "", ".agents", "skills"),
+	path.join(process.env.HOME || "", ".claude", "skills"),
+];
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+
+	const resolveRegistryPath = (cwd: string): string | null => {
+		for (const rel of SERVICE_REGISTRY_FILES) {
+			const candidate = path.join(cwd, rel);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+		return null;
+	};
+
+	const resolveSkillScript = (cwd: string, skillName: string, scriptName: string): string | null => {
+		const localPath = path.join(cwd, ".claude", "skills", skillName, "scripts", scriptName);
+		if (fs.existsSync(localPath)) return localPath;
+
+		for (const root of GLOBAL_SKILL_ROOTS) {
+			if (!root) continue;
+			const candidate = path.join(root, skillName, "scripts", scriptName);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+
+		return null;
+	};
+
+	// 1. Catalog Injection
+	pi.on("before_agent_start", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		const registryPath = resolveRegistryPath(cwd);
+		if (!registryPath) return undefined;
+
+		const catalogerPath = resolveSkillScript(cwd, "using-service-skills", "cataloger.py");
+		if (!catalogerPath) return undefined;
+
+		const result = await SubprocessRunner.run("python3", [catalogerPath], {
+			cwd,
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd,
+				SERVICE_REGISTRY_PATH: registryPath,
+			},
+		});
+
+		if (result.code === 0 && result.stdout.trim()) {
+			return { systemPrompt: event.systemPrompt + "\n\n" + result.stdout.trim() };
+		}
+		return undefined;
+	});
+
+	const toClaudeToolName = (toolName: string): string => {
+		if (toolName === "bash") return "Bash";
+		if (toolName === "read_file") return "Read";
+		if (toolName === "write" || toolName === "create_text_file") return "Write";
+		if (toolName === "edit" || toolName === "replace_content" || toolName === "replace_lines" || toolName === "insert_at_line" || toolName === "delete_lines") return "Edit";
+		if (toolName === "search_for_pattern") return "Grep";
+		if (toolName === "find_file" || toolName === "list_dir") return "Glob";
+		return toolName;
+	};
+
+	// 2. Drift Detection (skill activation is before_agent_start only — not per-tool)
+	pi.on("tool_result", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		const registryPath = resolveRegistryPath(cwd);
+		if (!registryPath) return undefined;
+
+		const driftDetectorPath = resolveSkillScript(cwd, "updating-service-skills", "drift_detector.py");
+		if (!driftDetectorPath) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: toClaudeToolName(event.toolName),
+			tool_input: event.input,
+			cwd,
+		});
+
+		const result = await SubprocessRunner.run("python3", [driftDetectorPath], {
+			cwd,
+			input: hookInput,
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd,
+				SERVICE_REGISTRY_PATH: registryPath,
+			},
+			timeoutMs: 10000,
+		});
+
+		if (result.code === 0 && result.stdout.trim()) {
+			const newContent = [...event.content];
+			newContent.push({ type: "text", text: "\n\n" + result.stdout.trim() });
+			return { content: newContent };
+		}
+
+		return undefined;
+	});
+}

package/.xtrm/ext-src/service-skills/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@xtrm/pi-service-skills",
+  "version": "1.0.0",
+  "description": "xtrm Pi extension: service-skills",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "keywords": [
+    "pi",
+    "extension",
+    "xtrm"
+  ],
+  "author": "xtrm",
+  "license": "MIT",
+  "dependencies": {
+    "@xtrm/pi-core": "^1.0.0"
+  }
+}

package/.xtrm/ext-src/session-flow/index.ts

@@ -0,0 +1,96 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter } from "@xtrm/pi-core";
+
+function isClaimCommand(command: string): { isClaim: boolean; issueId: string | null } {
+	if (!/\bbd\s+update\b/.test(command) || !/--claim\b/.test(command)) {
+		return { isClaim: false, issueId: null };
+	}
+	const match = command.match(/\bbd\s+update\s+(\S+)/);
+	return { isClaim: true, issueId: match?.[1] ?? null };
+}
+
+function isWorktree(cwd: string): boolean {
+	return cwd.includes("/.xtrm/worktrees/") || cwd.includes("/.claude/worktrees/");
+}
+
+function getSessionId(ctx: any): string {
+	return ctx?.sessionManager?.getSessionId?.() ?? ctx?.sessionId ?? ctx?.session_id ?? process.pid.toString();
+}
+
+async function getSessionClaim(cwd: string, sessionId: string): Promise<string | null> {
+	const claimResult = await SubprocessRunner.run("bd", ["kv", "get", `claimed:${sessionId}`], { cwd });
+	if (claimResult.code !== 0) return null;
+	const claimId = claimResult.stdout.trim();
+	return claimId.length > 0 ? claimId : null;
+}
+
+async function isClaimStillInProgress(cwd: string, issueId: string): Promise<boolean> {
+	const showResult = await SubprocessRunner.run("bd", ["show", issueId, "--json"], { cwd });
+	if (showResult.code === 0 && showResult.stdout.trim()) {
+		try {
+			const parsed = JSON.parse(showResult.stdout);
+			const record = Array.isArray(parsed) ? parsed[0] : parsed;
+			if (record?.status) return record.status === "in_progress";
+		} catch {
+			// fall back to text parsing below
+		}
+	}
+
+	const listResult = await SubprocessRunner.run("bd", ["list", "--status=in_progress"], { cwd });
+	if (listResult.code !== 0) return false;
+	const issuePattern = new RegExp(`^\\s*[◐●]?\\s*${issueId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "m");
+	return issuePattern.test(listResult.stdout);
+}
+
+export default function (pi: ExtensionAPI) {
+	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+	let lastStopNoticeIssue: string | null = null;
+	let lastWorktreeReminderCwd: string | null = null;
+
+	// Claim sync: notify when a bd update --claim command is run.
+	pi.on("tool_result", async (event, ctx) => {
+		if (!isBashToolResult(event)) return undefined;
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
+
+		const command = event.input.command || "";
+		const { isClaim, issueId } = isClaimCommand(command);
+		if (!isClaim || !issueId) return undefined;
+
+		const text = `\n\nSession Flow: claimed ${issueId}. Work in this session is tracked.`;
+		return { content: [...event.content, { type: "text", text }] };
+	});
+
+	// Stop gate: warn (non-blocking) if this session's claimed issue is still in progress.
+	// IMPORTANT: never call sendUserMessage() from agent_end, it always triggers a new turn.
+	pi.on("agent_end", async (_event, ctx) => {
+		const cwd = getCwd(ctx);
+		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
+
+		const sessionId = getSessionId(ctx);
+		const claimId = await getSessionClaim(cwd, sessionId);
+
+		if (claimId) {
+			const inProgress = await isClaimStillInProgress(cwd, claimId);
+			if (inProgress) {
+				if (lastStopNoticeIssue !== claimId && ctx.hasUI) {
+					ctx.ui.notify(`Stop blocked: close your issue first: bd close ${claimId}`, "warning");
+					lastStopNoticeIssue = claimId;
+				}
+				return undefined;
+			}
+
+			if (lastStopNoticeIssue === claimId) {
+				lastStopNoticeIssue = null;
+			}
+		}
+
+		if (isWorktree(cwd) && ctx.hasUI && lastWorktreeReminderCwd !== cwd) {
+			ctx.ui.notify("Run `xt end` to create a PR and clean up this worktree.", "info");
+			lastWorktreeReminderCwd = cwd;
+		}
+
+		return undefined;
+	});
+}

package/.xtrm/ext-src/session-flow/package.json

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

package/.xtrm/ext-src/xtrm-loader/index.ts

@@ -0,0 +1,152 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { Logger } from "@xtrm/pi-core";
+
+const logger = new Logger({ namespace: "xtrm-loader" });
+
+/**
+ * Recursively find markdown files in a directory.
+ */
+function findMarkdownFiles(dir: string, basePath: string = ""): string[] {
+	const results: string[] = [];
+	if (!fs.existsSync(dir)) return results;
+
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			results.push(...findMarkdownFiles(path.join(dir, entry.name), relativePath));
+		} else if (entry.isFile() && entry.name.endsWith(".md")) {
+			results.push(relativePath);
+		}
+	}
+	return results;
+}
+
+function resolveUsingXtrmSkillPath(cwd: string): string | null {
+	const candidates = [
+		path.join(homedir(), ".agents", "skills", "using-xtrm", "SKILL.md"),
+		path.join(homedir(), ".pi", "agent", "skills", "using-xtrm", "SKILL.md"),
+		path.join(cwd, ".pi", "skills", "using-xtrm", "SKILL.md"),
+	];
+
+	for (const candidate of candidates) {
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+
+/**
+ * Load a skill file, stripping YAML frontmatter.
+ */
+function loadSkillContent(skillPath: string): string | null {
+	try {
+		const content = fs.readFileSync(skillPath, "utf8");
+		return content.replace(/^---[\s\S]*?---\n/, "").trim();
+	} catch {
+		return null;
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	let projectContext: string = "";
+	let usingXtrmContent: string | null = null;
+
+	pi.on("session_start", async (_event, ctx) => {
+		const cwd = ctx.cwd;
+		const contextParts: string[] = [];
+
+		// 0. Load using-xtrm skill (global/project fallback paths)
+		const usingXtrmPath = resolveUsingXtrmSkillPath(cwd);
+		usingXtrmContent = usingXtrmPath ? loadSkillContent(usingXtrmPath) : null;
+		if (usingXtrmPath && usingXtrmContent) {
+			logger.info(`Loaded using-xtrm skill from ${usingXtrmPath}`);
+		}
+
+		// 1. Architecture & Roadmap
+		const roadmapPaths = [
+			path.join(cwd, "architecture", "project_roadmap.md"),
+			path.join(cwd, "ROADMAP.md"),
+			path.join(cwd, "architecture", "index.md"),
+		];
+
+		for (const p of roadmapPaths) {
+			if (fs.existsSync(p)) {
+				const content = await fs.promises.readFile(p, "utf8");
+				contextParts.push(`## Project Roadmap & Architecture (${path.relative(cwd, p)})\n\n${content}`);
+				break; // Only load the first one found
+			}
+		}
+
+		// 2. Project Rules (.claude/rules)
+		const rulesDir = path.join(cwd, ".claude", "rules");
+		if (fs.existsSync(rulesDir)) {
+			const ruleFiles = findMarkdownFiles(rulesDir);
+			if (ruleFiles.length > 0) {
+				const rulesContent = (
+					await Promise.all(
+						ruleFiles.map(async (f) => {
+							const content = await fs.promises.readFile(path.join(rulesDir, f), "utf8");
+							return `### Rule: ${f}\n${content}`;
+						}),
+					)
+				).join("\n\n");
+				contextParts.push(`## Project Rules\n\n${rulesContent}`);
+			}
+		}
+
+		// 3. Project Skills (.claude/skills)
+		const skillsDir = path.join(cwd, ".claude", "skills");
+		if (fs.existsSync(skillsDir)) {
+			const skillFiles = findMarkdownFiles(skillsDir);
+			if (skillFiles.length > 0) {
+				const skillsContent = skillFiles
+					.map((f) => `- ${f} (Path: .claude/skills/${f})`)
+					.join("\n");
+				contextParts.push(
+					`## Available Project Skills\n\nExisting service skills and workflows found in .claude/skills/:\n\n${skillsContent}\n\nUse the read tool to load any of these skills if relevant to the current task.`,
+				);
+			}
+		}
+
+		projectContext = contextParts.join("\n\n---\n\n");
+
+		if (projectContext && ctx.hasUI) {
+			ctx.ui.notify("XTRM-Loader: Project context and skills indexed", "info");
+		}
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		const parts: string[] = [];
+
+		// Prepend using-xtrm skill (session operating manual)
+		if (usingXtrmContent) {
+			parts.push("# XTRM Session Operating Manual\n\n" + usingXtrmContent);
+		}
+
+		// Inject .xtrm/memory.md if present (synthesized project context)
+		const memoryPath = path.join(ctx.cwd, ".xtrm", "memory.md");
+		if (fs.existsSync(memoryPath)) {
+			try {
+				const memoryContent = fs.readFileSync(memoryPath, "utf8").trim();
+				if (memoryContent) {
+					parts.push(memoryContent);
+					logger.info(`Injected .xtrm/memory.md (${memoryContent.length} chars)`);
+				}
+			} catch { /* fail open */ }
+		}
+
+		// Append project context
+		if (projectContext) {
+			parts.push("# Project Intelligence Context\n\n" + projectContext);
+		}
+
+		if (parts.length === 0) return undefined;
+
+		return {
+			systemPrompt: event.systemPrompt + "\n\n" + parts.join("\n\n---\n\n"),
+		};
+	});
+}

package/.xtrm/ext-src/xtrm-loader/package.json

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