xtrm-cli 0.5.0

package/extensions/minimal-mode.ts

@@ -0,0 +1,201 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+	createWriteTool,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+
+function getTextContent(result: any): string {
+	if (!result?.content || !Array.isArray(result.content)) return "";
+	return result.content
+		.filter((c: any) => c?.type === "text" && typeof c.text === "string")
+		.map((c: any) => c.text)
+		.join("\n")
+		.trim();
+}
+
+function oneLine(s: string): string {
+	return (s || "").replace(/\s+/g, " ").trim();
+}
+
+function summarize(result: any): { text: string; isError: boolean } {
+	const raw = getTextContent(result);
+	if (!raw) return { text: "done", isError: false };
+	const line = oneLine(raw.split("\n").find((l) => l.trim()) || "");
+	const lower = line.toLowerCase();
+	const isError = lower.includes("error") || lower.includes("failed") || lower.includes("exception");
+	return { text: line.slice(0, 140) || "done", isError };
+}
+
+const toolCache = new Map<string, ReturnType<typeof createBuiltInTools>>();
+function createBuiltInTools(cwd: string) {
+	return {
+		read: createReadTool(cwd),
+		bash: createBashTool(cwd),
+		edit: createEditTool(cwd),
+		write: createWriteTool(cwd),
+		find: createFindTool(cwd),
+		grep: createGrepTool(cwd),
+		ls: createLsTool(cwd),
+	};
+}
+function getBuiltInTools(cwd: string) {
+	let tools = toolCache.get(cwd);
+	if (!tools) {
+		tools = createBuiltInTools(cwd);
+		toolCache.set(cwd, tools);
+	}
+	return tools;
+}
+
+export default function (pi: ExtensionAPI) {
+	let minimalEnabled = true;
+	let thinkingStatusEnabled = true;
+	let spinnerTimer: NodeJS.Timeout | null = null;
+	let spinnerIndex = 0;
+	const frames = ["thinking   ", "thinking.  ", "thinking.. ", "thinking..."];
+
+	const clearSpinner = (ctx: any) => {
+		if (spinnerTimer) {
+			clearInterval(spinnerTimer);
+			spinnerTimer = null;
+		}
+		if (ctx?.hasUI) {
+			ctx.ui.setStatus("thinking", undefined);
+			ctx.ui.setHeader(undefined);
+		}
+	};
+
+	const mountThinkingHeader = (ctx: any) => {
+		if (!ctx?.hasUI) return;
+		ctx.ui.setHeader((_tui: any, theme: any) => ({
+			invalidate() {},
+			render(width: number): string[] {
+				const text = frames[spinnerIndex];
+				return [oneLine(theme.fg("accent", text)).slice(0, width)];
+			},
+		}));
+	};
+
+	const startSpinner = (ctx: any) => {
+		if (!thinkingStatusEnabled || !ctx?.hasUI) return;
+		clearSpinner(ctx);
+		spinnerIndex = 0;
+		ctx.ui.setStatus("thinking", frames[spinnerIndex]);
+		mountThinkingHeader(ctx);
+		spinnerTimer = setInterval(() => {
+			spinnerIndex = (spinnerIndex + 1) % frames.length;
+			ctx.ui.setStatus("thinking", frames[spinnerIndex]);
+			mountThinkingHeader(ctx);
+		}, 220);
+	};
+
+	const renderCollapsedResult = (result: any, theme: any) => {
+		const s = summarize(result);
+		const icon = s.isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
+		const text = s.isError ? theme.fg("error", s.text) : theme.fg("muted", s.text);
+		if (minimalEnabled) return new Text(` ${icon} ${text}`, 0, 0);
+		return new Text(theme.fg("muted", ` → ${s.text}`), 0, 0);
+	};
+
+	const renderExpandedResult = (result: any, theme: any) => {
+		const text = getTextContent(result);
+		if (!text) return new Text("", 0, 0);
+		const output = text.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
+		return new Text(`\n${output}`, 0, 0);
+	};
+
+	pi.registerTool({
+		name: "bash",
+		label: "bash",
+		description: getBuiltInTools(process.cwd()).bash.description,
+		parameters: getBuiltInTools(process.cwd()).bash.parameters,
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			return getBuiltInTools(ctx.cwd).bash.execute(toolCallId, params, signal, onUpdate);
+		},
+		renderCall(args, theme) {
+			const cmd = oneLine(args.command || "");
+			return new Text(`${theme.fg("toolTitle", theme.bold("bash"))}(${theme.fg("accent", cmd || "...")})`, 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			return expanded ? renderExpandedResult(result, theme) : renderCollapsedResult(result, theme);
+		},
+	});
+
+	for (const name of ["read", "write", "edit", "find", "grep", "ls"] as const) {
+		pi.registerTool({
+			name,
+			label: name,
+			description: (getBuiltInTools(process.cwd()) as any)[name].description,
+			parameters: (getBuiltInTools(process.cwd()) as any)[name].parameters,
+			async execute(toolCallId, params, signal, onUpdate, ctx) {
+				return (getBuiltInTools(ctx.cwd) as any)[name].execute(toolCallId, params, signal, onUpdate);
+			},
+			renderCall(args, theme) {
+				const suffix = oneLine(args.path || args.pattern || "");
+				return new Text(`${theme.fg("toolTitle", theme.bold(name))}${suffix ? `(${theme.fg("accent", suffix)})` : ""}`, 0, 0);
+			},
+			renderResult(result, { expanded }, theme) {
+				return expanded ? renderExpandedResult(result, theme) : renderCollapsedResult(result, theme);
+			},
+		});
+	}
+
+	pi.registerCommand("minimal-on", {
+		description: "Enable minimal collapsed tool output",
+		handler: async (_args, ctx) => {
+			minimalEnabled = true;
+			ctx.ui.notify("Minimal mode enabled", "info");
+		},
+	});
+
+	pi.registerCommand("minimal-off", {
+		description: "Disable minimal collapsed tool output",
+		handler: async (_args, ctx) => {
+			minimalEnabled = false;
+			ctx.ui.notify("Minimal mode disabled", "info");
+		},
+	});
+
+	pi.registerCommand("minimal-toggle", {
+		description: "Toggle minimal collapsed tool output",
+		handler: async (_args, ctx) => {
+			minimalEnabled = !minimalEnabled;
+			ctx.ui.notify(`Minimal mode ${minimalEnabled ? "enabled" : "disabled"}`, "info");
+		},
+	});
+
+	pi.registerCommand("thinking-status-toggle", {
+		description: "Toggle flashing thinking status indicator",
+		handler: async (_args, ctx) => {
+			thinkingStatusEnabled = !thinkingStatusEnabled;
+			if (!thinkingStatusEnabled) clearSpinner(ctx);
+			ctx.ui.notify(`Thinking status ${thinkingStatusEnabled ? "enabled" : "disabled"}`, "info");
+		},
+	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		startSpinner(ctx);
+		return undefined;
+	});
+
+	pi.on("turn_end", async (_event, ctx) => {
+		clearSpinner(ctx);
+		return undefined;
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		clearSpinner(ctx);
+		return undefined;
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		clearSpinner(ctx);
+		return undefined;
+	});
+}

package/extensions/quality-gates.ts

@@ -0,0 +1,67 @@
+import type { ExtensionAPI, ToolResultEvent } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter, Logger } from "./core/lib";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const logger = new Logger({ namespace: "quality-gates" });
+
+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);
+
+		let scriptPath: string | null = null;
+		let runner: string = "node";
+
+		if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+			scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.cjs");
+			runner = "node";
+		} else if (ext === ".py") {
+			scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.py");
+			runner = "python3";
+		}
+
+		if (!scriptPath || !fs.existsSync(scriptPath)) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: event.toolName,
+			tool_input: event.input,
+			cwd: cwd,
+		});
+
+		const result = await SubprocessRunner.run(runner, [scriptPath], {
+			cwd,
+			input: hookInput,
+			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
+			timeoutMs: 30000,
+		});
+
+		if (result.code === 0) {
+			if (result.stderr && result.stderr.trim()) {
+				const newContent = [...event.content];
+				newContent.push({ type: "text", text: `\n\n**Quality Gate**: ${result.stderr.trim()}` });
+				return { content: newContent };
+			}
+			return undefined;
+		}
+
+		if (result.code === 2) {
+			const newContent = [...event.content];
+			newContent.push({ type: "text", text: `\n\n**Quality Gate FAILED**:\n${result.stderr || result.stdout || "Unknown error"}` });
+			
+			if (ctx.hasUI) {
+				ctx.ui.notify(`Quality Gate failed for ${path.basename(fullPath)}`, "error");
+			}
+
+			return { isError: true, content: newContent };
+		}
+
+		return undefined;
+	});
+}

package/extensions/service-skills.ts

@@ -0,0 +1,150 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, Logger } from "./core/lib";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const logger = new Logger({ namespace: "service-skills" });
+
+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;
+	};
+
+	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;
+	};
+
+	// 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;
+	});
+
+	// 2. Territory Activation (optional; no-op when script not available)
+	pi.on("tool_call", async (event, ctx) => {
+		const cwd = getCwd(ctx);
+		const registryPath = resolveRegistryPath(cwd);
+		if (!registryPath) return undefined;
+
+		const activatorPath = resolveSkillScript(cwd, "using-service-skills", "skill_activator.py");
+		if (!activatorPath) return undefined;
+
+		const hookInput = JSON.stringify({
+			tool_name: toClaudeToolName(event.toolName),
+			tool_input: event.input,
+			cwd,
+		});
+
+		const result = await SubprocessRunner.run("python3", [activatorPath], {
+			cwd,
+			input: hookInput,
+			env: {
+				...process.env,
+				CLAUDE_PROJECT_DIR: cwd,
+				SERVICE_REGISTRY_PATH: registryPath,
+			},
+			timeoutMs: 5000,
+		});
+
+		if (result.code === 0 && result.stdout.trim()) {
+			try {
+				const parsed = JSON.parse(result.stdout.trim());
+				const context = parsed.hookSpecificOutput?.additionalContext;
+				if (context && ctx.hasUI) {
+					ctx.ui.notify(context, "info");
+				}
+			} catch (e) {
+				logger.error("Failed to parse skill_activator output", e);
+			}
+		}
+
+		return undefined;
+	});
+
+	// 3. Drift Detection
+	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/extensions/xtrm-loader.ts

@@ -0,0 +1,89 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Logger } from "./core/lib";
+
+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;
+}
+
+export default function (pi: ExtensionAPI) {
+	let projectContext: string = "";
+
+	pi.on("session_start", async (_event, ctx) => {
+		const cwd = ctx.cwd;
+		const contextParts: string[] = [];
+
+		// 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 = fs.readFileSync(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 = ruleFiles.map(f => {
+					const content = fs.readFileSync(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 => {
+					// We only want to list the paths/names so the agent knows what it can read
+					return `- ${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) => {
+		if (!projectContext) return undefined;
+
+		return {
+			systemPrompt: event.systemPrompt + "\n\n# Project Intelligence Context\n\n" + projectContext
+		};
+	});
+}

package/hooks/gitnexus-impact-reminder.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+import sys
+import os
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from agent_context import AgentContext
+
+try:
+    ctx = AgentContext()
+    ctx.fail_open()
+except Exception as e:
+    print(f"Hook error: {e}", file=sys.stderr)
+    sys.exit(0)