xtrm-cli 0.5.0

package/test/extensions/beads.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import beadsExtension from "../../extensions/beads";
+import { SubprocessRunner } from "../../extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event) => event.toolName === "write"),
+		},
+		Logger: vi.fn().mockImplementation(function() {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+}));
+
+describe("Beads Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		(fs.existsSync as any).mockReturnValue(true);
+	});
+
+	it("should block edits when claim check fails", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 1, stdout: "", stderr: "" };
+			if (args[0] === "list") {
+                return { code: 0, stdout: "Total: 5 issues (3 open, 2 in progress)", stderr: "" };
+            }
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toBeDefined();
+        if (result) {
+		    expect(result.block).toBe(true);
+		    expect(result.reason).toContain("No active issue claim");
+        }
+	});
+
+	it("should allow edits when an issue is claimed", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "issue-123", stderr: "" };
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it("should block git commit when an issue is claimed", async () => {
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "get") return { code: 0, stdout: "issue-123", stderr: "" };
+			if (args[0] === "list") {
+                return { code: 0, stdout: "Total: 1 issues (0 open, 1 in progress)\n◐ issue-123 Title", stderr: "" };
+            }
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "bash",
+			input: { command: "git commit -m 'feat: something'" },
+		});
+
+		expect(result).toBeDefined();
+        if (result) {
+		    expect(result.block).toBe(true);
+		    expect(result.reason).toContain("Resolve open claim [issue-123]");
+        }
+	});
+
+	it("should inject memory reminder on bd close", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "", stderr: "" });
+		
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd close issue-123" },
+			content: [{ type: "text", text: "Issue closed successfully." }],
+			isError: false,
+		});
+
+		expect(result.content).toHaveLength(2);
+		expect(result.content[1].text).toContain("Beads Insight");
+	});
+
+	it("should auto-claim session on bd update --claim", async () => {
+		const kvSetCalls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "set") {
+				kvSetCalls.push(args);
+				return { code: 0, stdout: "", stderr: "" };
+			}
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd update issue-456 --claim" },
+			content: [{ type: "text", text: "Updated issue: issue-456" }],
+			isError: false,
+		});
+
+		expect(kvSetCalls.length).toBe(1);
+		expect(kvSetCalls[0][2]).toBe(`claimed:${process.pid}`);
+		expect(kvSetCalls[0][3]).toBe("issue-456");
+		expect(result.content[1].text).toContain("claimed issue");
+		expect(result.content[1].text).toContain("issue-456");
+	});
+
+
+	it("should auto-claim even when bd update --claim returns exit 1 (already in_progress)", async () => {
+		const kvSetCalls: string[][] = [];
+		(SubprocessRunner.run as any).mockImplementation(async (cmd: string, args: string[]) => {
+			if (args[0] === "kv" && args[1] === "set") {
+				kvSetCalls.push(args);
+				return { code: 0, stdout: "", stderr: "" };
+			}
+			return { code: 0, stdout: "", stderr: "" };
+		});
+
+		beadsExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "bash",
+			input: { command: "bd update issue-789 --claim" },
+			content: [{ type: "text", text: "already in_progress" }],
+			isError: true,
+		});
+
+		expect(kvSetCalls.length).toBe(1);
+		expect(kvSetCalls[0][2]).toBe(`claimed:${process.pid}`);
+		expect(kvSetCalls[0][3]).toBe("issue-789");
+		expect(result.content[1].text).toContain("issue-789");
+	});
+});

package/test/extensions/extension-harness.ts

@@ -0,0 +1,85 @@
+import { vi } from "vitest";
+
+export interface MockUI {
+	notify: any;
+	confirm: any;
+	select: any;
+	setStatus: any;
+	theme: {
+		fg: any;
+	};
+}
+
+export interface MockSessionManager {
+	sessionId: string;
+	getEntries: any;
+	getLeafEntry: any;
+	getBranch: any;
+}
+
+export interface MockContext {
+	cwd: string;
+	hasUI: boolean;
+	ui: MockUI;
+	sessionManager: MockSessionManager;
+	getSystemPrompt: any;
+}
+
+export class ExtensionHarness {
+	public handlers: Record<string, Function[]> = {};
+	public commands: Record<string, any> = {};
+	public tools: Record<string, any> = {};
+	public ctx: MockContext;
+	public pi: any;
+
+	constructor(cwd: string = "/mock/project") {
+		this.ctx = {
+			cwd,
+			hasUI: true,
+			ui: {
+				notify: vi.fn(),
+				confirm: vi.fn().mockResolvedValue(true),
+				select: vi.fn().mockResolvedValue(""),
+				setStatus: vi.fn(),
+				theme: {
+					fg: vi.fn((_color: string, text: string) => text),
+				},
+			},
+			sessionManager: {
+				sessionId: "mock-session-123",
+				getEntries: vi.fn().mockReturnValue([]),
+				getLeafEntry: vi.fn().mockReturnValue({ id: "last-entry" }),
+				getBranch: vi.fn().mockReturnValue([]),
+			},
+			getSystemPrompt: vi.fn().mockReturnValue("Default system prompt"),
+		};
+
+		this.pi = {
+			on: (event: string, handler: Function) => {
+				if (!this.handlers[event]) this.handlers[event] = [];
+				this.handlers[event].push(handler);
+			},
+			exec: vi.fn().mockResolvedValue({ code: 0, stdout: "", stderr: "" }),
+			registerCommand: (cmd: any) => {
+				this.commands[cmd.name] = cmd;
+			},
+			registerTool: (tool: any) => {
+				this.tools[tool.name] = tool;
+			},
+		};
+	}
+
+	async emit(event: string, data: any) {
+		if (this.handlers[event]) {
+            let lastResult: any = undefined;
+			for (const handler of this.handlers[event]) {
+				console.log("EXECUTING HANDLER"); const res = await handler(data, this.ctx); console.log("HANDLER RESULT", res);
+				if (res !== undefined) {
+                    lastResult = res; console.log("EMIT FOUND RESULT", res);
+                }
+			}
+            return lastResult;
+		}
+		return undefined;
+	}
+}

package/test/extensions/main-guard.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import mainGuardExtension from "../../extensions/main-guard";
+import { SubprocessRunner } from "../../extensions/core/lib";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event) => event.toolName === "write" || event.toolName === "edit"),
+			extractPathFromToolInput: vi.fn((event) => event.input.path),
+		},
+		Logger: vi.fn().mockImplementation(function() {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+describe("Main Guard Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+	});
+
+	it("should block edits on main branch", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "main" });
+
+		mainGuardExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toEqual({
+			block: true,
+			reason: expect.stringContaining("On protected branch 'main'"),
+		});
+	});
+
+	it("should allow edits on feature branches", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "feature/abc" });
+
+		mainGuardExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it("should block rm -rf with confirmation", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({ code: 0, stdout: "feature/abc" });
+		harness.ctx.ui.confirm = vi.fn().mockResolvedValue(false);
+
+		mainGuardExtension(harness.pi);
+
+		const result = await harness.emit("tool_call", {
+			toolName: "bash",
+			input: { command: "rm -rf /important/stuff" },
+		});
+
+		expect(result).toEqual({
+			block: true,
+			reason: "Blocked by user confirmation",
+		});
+	});
+});

package/test/extensions/minimal-mode.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import minimalModeExtension from "../../extensions/minimal-mode";
+
+vi.mock("@mariozechner/pi-coding-agent", async () => {
+	const mk = () => ({
+		description: "mock",
+		parameters: { type: "object", properties: {} },
+		execute: vi.fn(async () => ({ content: [{ type: "text", text: "ok" }] })),
+	});
+	return {
+		createReadTool: () => mk(),
+		createBashTool: () => mk(),
+		createEditTool: () => mk(),
+		createWriteTool: () => mk(),
+		createFindTool: () => mk(),
+		createGrepTool: () => mk(),
+		createLsTool: () => mk(),
+	};
+});
+
+vi.mock("@mariozechner/pi-tui", async () => {
+	class Text {
+		constructor(public value: string) {}
+	}
+	return { Text };
+});
+
+describe("minimal-mode extension", () => {
+	let handlers: Record<string, Function[]>;
+	let commands: Record<string, any>;
+	let tools: Record<string, any>;
+	let ctx: any;
+	let pi: any;
+
+	beforeEach(() => {
+		vi.useFakeTimers();
+		handlers = {};
+		commands = {};
+		tools = {};
+		ctx = {
+			cwd: "/mock/project",
+			hasUI: true,
+			ui: {
+				notify: vi.fn(),
+				setStatus: vi.fn(),
+				setHeader: vi.fn(),
+				theme: {
+					fg: vi.fn((_color: string, text: string) => text),
+					bold: vi.fn((text: string) => text),
+				},
+			},
+		};
+		pi = {
+			on: (event: string, handler: Function) => {
+				if (!handlers[event]) handlers[event] = [];
+				handlers[event].push(handler);
+			},
+			registerTool: (tool: any) => {
+				tools[tool.name] = tool;
+			},
+			registerCommand: (nameOrDef: any, maybeDef?: any) => {
+				if (typeof nameOrDef === "string") commands[nameOrDef] = maybeDef;
+				else commands[nameOrDef.name] = nameOrDef;
+			},
+		};
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	const emit = async (event: string, data: any = {}) => {
+		for (const h of handlers[event] || []) await h(data, ctx);
+	};
+
+	it("registers minimal/thinking commands and tool overrides", () => {
+		minimalModeExtension(pi);
+
+		expect(commands["minimal-on"]).toBeDefined();
+		expect(commands["minimal-off"]).toBeDefined();
+		expect(commands["minimal-toggle"]).toBeDefined();
+		expect(commands["thinking-status-toggle"]).toBeDefined();
+
+		expect(tools["bash"]).toBeDefined();
+		expect(tools["read"]).toBeDefined();
+		expect(tools["write"]).toBeDefined();
+		expect(tools["edit"]).toBeDefined();
+		expect(tools["find"]).toBeDefined();
+		expect(tools["grep"]).toBeDefined();
+		expect(tools["ls"]).toBeDefined();
+	});
+
+	it("starts and clears thinking status/header across turn lifecycle", async () => {
+		minimalModeExtension(pi);
+
+		await emit("turn_start", {});
+		expect(ctx.ui.setStatus).toHaveBeenCalledWith("thinking", "thinking   ");
+		expect(ctx.ui.setHeader).toHaveBeenCalled();
+
+		vi.advanceTimersByTime(240);
+		expect(ctx.ui.setStatus).toHaveBeenCalledWith("thinking", "thinking.  ");
+
+		await emit("turn_end", {});
+		expect(ctx.ui.setStatus).toHaveBeenCalledWith("thinking", undefined);
+		expect(ctx.ui.setHeader).toHaveBeenCalledWith(undefined);
+	});
+});

package/test/extensions/quality-gates.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import qualityGatesExtension from "../../extensions/quality-gates";
+import { SubprocessRunner } from "../../extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		EventAdapter: {
+			isMutatingFileTool: vi.fn((event) => event.toolName === "write" || event.toolName === "edit"),
+			extractPathFromToolInput: vi.fn((event) => event.input.path),
+		},
+		Logger: vi.fn().mockImplementation(function() {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+}));
+
+describe("Quality Gates Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+		(fs.existsSync as any).mockReturnValue(true);
+	});
+
+	it("should run quality check for .ts files", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({
+			code: 0,
+			stdout: "Passed",
+			stderr: "ESLint auto-fixed issues",
+		});
+
+		qualityGatesExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+			content: [{ type: "text", text: "Original content" }],
+		});
+
+		expect(SubprocessRunner.run).toHaveBeenCalledWith(
+			"node",
+			expect.arrayContaining([expect.stringContaining("quality-check.cjs")]),
+			expect.any(Object)
+		);
+		expect(result.content[1].text).toContain("ESLint auto-fixed issues");
+	});
+
+	it("should fail tool result when quality check returns status 2", async () => {
+		(SubprocessRunner.run as any).mockResolvedValue({
+			code: 2,
+			stdout: "",
+			stderr: "Compilation failed: error TS1234",
+		});
+
+		qualityGatesExtension(harness.pi);
+
+		const result = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "src/main.ts" },
+			content: [{ type: "text", text: "Original content" }],
+		});
+
+		expect(result.isError).toBe(true);
+		expect(result.content[1].text).toContain("Compilation failed");
+	});
+});

package/test/extensions/service-skills.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import serviceSkillsExtension from "../../extensions/service-skills";
+import { SubprocessRunner } from "../../extensions/core/lib";
+import * as fs from "node:fs";
+
+vi.mock("../../extensions/core/lib", async () => {
+	return {
+		SubprocessRunner: {
+			run: vi.fn(),
+		},
+		Logger: vi.fn().mockImplementation(function () {
+			this.debug = vi.fn();
+			this.info = vi.fn();
+			this.warn = vi.fn();
+			this.error = vi.fn();
+		}),
+	};
+});
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+}));
+
+describe("Service Skills Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness("/mock/project");
+	});
+
+	it("gracefully no-ops when service-registry.json is absent", async () => {
+		(fs.existsSync as any).mockReturnValue(false);
+
+		serviceSkillsExtension(harness.pi);
+
+		const beforeStart = await harness.emit("before_agent_start", {
+			systemPrompt: "Base prompt",
+		});
+		const toolResult = await harness.emit("tool_result", {
+			toolName: "write",
+			input: { path: "src/file.ts" },
+			content: [{ type: "text", text: "ok" }],
+		});
+
+		expect(beforeStart).toBeUndefined();
+		expect(toolResult).toBeUndefined();
+		expect(SubprocessRunner.run).not.toHaveBeenCalled();
+	});
+
+	it("injects catalog when registry + cataloger script are present", async () => {
+		(fs.existsSync as any).mockImplementation((p: string) => {
+			if (p === "/mock/project/service-registry.json") return true;
+			if (p.includes(".claude/skills/using-service-skills/scripts/cataloger.py")) return true;
+			return false;
+		});
+
+		(SubprocessRunner.run as any).mockResolvedValue({
+			code: 0,
+			stdout: "<project_service_catalog>...</project_service_catalog>",
+			stderr: "",
+		});
+
+		serviceSkillsExtension(harness.pi);
+
+		const result = await harness.emit("before_agent_start", {
+			systemPrompt: "Base prompt",
+		});
+
+		expect(SubprocessRunner.run).toHaveBeenCalledWith(
+			"python3",
+			expect.arrayContaining([expect.stringContaining("cataloger.py")]),
+			expect.objectContaining({
+				cwd: "/mock/project",
+				env: expect.objectContaining({
+					CLAUDE_PROJECT_DIR: "/mock/project",
+					SERVICE_REGISTRY_PATH: "/mock/project/service-registry.json",
+				}),
+			}),
+		);
+		expect(result.systemPrompt).toContain("project_service_catalog");
+	});
+});

package/test/extensions/xtrm-loader.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExtensionHarness } from "./extension-harness";
+import xtrmLoaderExtension from "../../extensions/xtrm-loader";
+import * as fs from "node:fs";
+
+vi.mock("node:fs", () => ({
+	existsSync: vi.fn(),
+	readFileSync: vi.fn(),
+	readdirSync: vi.fn(),
+}));
+
+describe("XTRM Loader Extension", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(() => {
+		vi.resetAllMocks();
+		harness = new ExtensionHarness();
+	});
+
+	it("should load project roadmap and rules", async () => {
+		(fs.existsSync as any).mockImplementation((p: string) => {
+			if (p.endsWith("ROADMAP.md")) return true;
+			if (p.endsWith(".claude/rules")) return true;
+			if (p.endsWith(".claude/skills")) return false;
+			return false;
+		});
+
+		(fs.readFileSync as any).mockImplementation((p: string) => {
+			if (p.endsWith("ROADMAP.md")) return "My Roadmap Content";
+			if (p.endsWith("rule1.md")) return "Rule 1 Content";
+			return "";
+		});
+
+		(fs.readdirSync as any).mockImplementation((p: string) => {
+			if (p.endsWith(".claude/rules")) return [{ name: "rule1.md", isFile: () => true, isDirectory: () => false }];
+			return [];
+		});
+
+		xtrmLoaderExtension(harness.pi);
+
+		// Trigger session_start to load data
+		await harness.emit("session_start", {});
+
+		// Trigger before_agent_start to see injection
+		const result = await harness.emit("before_agent_start", {
+			systemPrompt: "Base prompt"
+		});
+
+		expect(result.systemPrompt).toContain("My Roadmap Content");
+		expect(result.systemPrompt).toContain("Rule 1 Content");
+		expect(harness.ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("context and skills indexed"), "info");
+	});
+});

package/test/hooks/quality-check-hooks.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+describe('Quality check hooks graceful no-op', () => {
+    it('quality-check.cjs exits 0 when tsconfig/tooling is absent', async () => {
+        const temp = await mkdtemp(path.join(tmpdir(), 'xtrm-qg-node-'));
+        try {
+            await writeFile(path.join(temp, 'a.js'), 'const x = 1;\n', 'utf8');
+
+            const nodeHookPath = path.resolve(__dirname, '../../../hooks/quality-check.cjs');
+            const result = spawnSync('node', [nodeHookPath], {
+                cwd: temp,
+                encoding: 'utf8',
+                input: JSON.stringify({ tool_input: { path: 'a.js' } }),
+                env: { ...process.env, CLAUDE_PROJECT_DIR: temp },
+            });
+
+            expect(result.status).toBe(0);
+        } finally {
+            await rm(temp, { recursive: true, force: true });
+        }
+    });
+
+    it('quality-check.py exits 0 when pyproject/.python-version is absent', async () => {
+        const temp = await mkdtemp(path.join(tmpdir(), 'xtrm-qg-py-'));
+        try {
+            await writeFile(path.join(temp, 'a.py'), 'print("hello")\n', 'utf8');
+
+            const pythonHookPath = path.resolve(__dirname, '../../../hooks/quality-check.py');
+            const result = spawnSync('python3', [pythonHookPath], {
+                cwd: temp,
+                encoding: 'utf8',
+                input: JSON.stringify({ tool_input: { path: 'a.py' } }),
+                env: { ...process.env, CLAUDE_PROJECT_DIR: temp },
+            });
+
+            expect(result.status).toBe(0);
+        } finally {
+            await rm(temp, { recursive: true, force: true });
+        }
+    });
+});