xtrm-cli 2.1.19 → 2.1.28

package/src/commands/install-project.ts

@@ -139,6 +139,94 @@ export async function getAvailableProjectSkills(): Promise<string[]> {
  * Deep merge settings.json hooks without overwriting existing user hooks.
  * Appends new hooks to existing events intelligently.
  */
+/**
+ * Extract script filename from a hook command.
+ */
+function getScriptFilename(hook: any): string | null {
+    const cmd = hook.command || hook.hooks?.[0]?.command || '';
+    if (typeof cmd !== 'string') return null;
+    // Match script filename including subdirectory (e.g., "gitnexus/gitnexus-hook.cjs")
+    const m = cmd.match(/\/hooks\/([A-Za-z0-9_/-]+\.(?:py|cjs|mjs|js))/);
+    if (m) return m[1];
+    const m2 = cmd.match(/([A-Za-z0-9_-]+\.(?:py|cjs|mjs|js))(?!.*[A-Za-z0-9._-]+\.(?:py|cjs|mjs|js))/);
+    return m2?.[1] ?? null;
+}
+
+/**
+ * Prune hooks from settings.json that are NOT in the canonical config.
+ * This removes stale entries from old versions before merging new ones.
+ * 
+ * @param existing Current settings.json hooks
+ * @param canonical Canonical hooks config from hooks.json
+ * @returns Pruned settings with stale hooks removed
+ */
+export function pruneStaleHooks(
+    existing: Record<string, any>,
+    canonical: Record<string, any>,
+): { result: Record<string, any>; removed: string[] } {
+    const result = { ...existing };
+    const removed: string[] = [];
+
+    if (!result.hooks || typeof result.hooks !== 'object') {
+        return { result, removed };
+    }
+    if (!canonical.hooks || typeof canonical.hooks !== 'object') {
+        return { result, removed };
+    }
+
+    // Collect all canonical script filenames
+    const canonicalScripts = new Set<string>();
+    for (const [event, hooks] of Object.entries(canonical.hooks)) {
+        const hookList = Array.isArray(hooks) ? hooks : [hooks];
+        for (const wrapper of hookList) {
+            const innerHooks = wrapper.hooks || [wrapper];
+            for (const hook of innerHooks) {
+                const script = getScriptFilename(hook);
+                if (script) canonicalScripts.add(script);
+            }
+        }
+    }
+
+    // Prune existing hooks not in canonical
+    for (const [event, hooks] of Object.entries(result.hooks)) {
+        if (!Array.isArray(hooks)) continue;
+
+        const prunedWrappers: any[] = [];
+        for (const wrapper of hooks) {
+            const innerHooks = wrapper.hooks || [wrapper];
+            const keptInner: any[] = [];
+
+            for (const hook of innerHooks) {
+                const script = getScriptFilename(hook);
+                // Keep if: no script (not a file-based hook) OR script is canonical
+                if (!script || canonicalScripts.has(script)) {
+                    keptInner.push(hook);
+                } else {
+                    removed.push(`${event}:${script}`);
+                }
+            }
+
+            if (keptInner.length > 0) {
+                if (wrapper.hooks) {
+                    prunedWrappers.push({ ...wrapper, hooks: keptInner });
+                } else if (keptInner.length === 1) {
+                    prunedWrappers.push(keptInner[0]);
+                } else {
+                    prunedWrappers.push({ ...wrapper, hooks: keptInner });
+                }
+            }
+        }
+
+        if (prunedWrappers.length > 0) {
+            result.hooks[event] = prunedWrappers;
+        } else {
+            delete result.hooks[event];
+        }
+    }
+
+    return { result, removed };
+}
+
 export function deepMergeHooks(existing: Record<string, any>, incoming: Record<string, any>): Record<string, any> {
     const result = { ...existing };
 
@@ -266,7 +354,15 @@ export async function installProjectSkill(toolName: string, projectRootOverride?
         }
 
         const incomingSettings = JSON.parse(await fs.readFile(skillSettingsPath, 'utf8'));
-        const mergedSettings = deepMergeHooks(existingSettings, incomingSettings);
+        
+        // First prune stale hooks not in canonical config
+        const { result: prunedSettings, removed } = pruneStaleHooks(existingSettings, incomingSettings);
+        if (removed.length > 0) {
+            console.log(kleur.yellow(`  ↳ Pruned ${removed.length} stale hook(s): ${removed.join(', ')}`));
+        }
+        
+        // Then merge canonical hooks
+        const mergedSettings = deepMergeHooks(prunedSettings, incomingSettings);
 
         await fs.writeFile(targetSettingsPath, JSON.stringify(mergedSettings, null, 2) + '\n');
         console.log(`${kleur.green('  ✓')} settings.json (hooks merged)`);

package/src/index.ts

@@ -13,6 +13,7 @@ import { createProjectCommand } from './commands/install-project.js';
 import { createStatusCommand } from './commands/status.js';
 import { createResetCommand } from './commands/reset.js';
 import { createHelpCommand } from './commands/help.js';
+import { createCleanCommand } from './commands/clean.js';
 import { printBanner } from './utils/banner.js';
 
 const program = new Command();
@@ -36,6 +37,7 @@ program.addCommand(createInstallCommand());
 program.addCommand(createProjectCommand());
 program.addCommand(createStatusCommand());
 program.addCommand(createResetCommand());
+program.addCommand(createCleanCommand());
 program.addCommand(createHelpCommand());
 
 // Default action: show help

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/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/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");
+	});
+});