@selesai/code 0.10.2 → 0.11.0

package/dist/extensions/pi-tool-display/tests/capabilities-edge.test.ts

@@ -0,0 +1,360 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import {
+	applyCapabilityConfigGuards,
+	detectToolDisplayCapabilities,
+} from "../src/capabilities.ts";
+import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../src/types.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createApiStub(
+	allTools: unknown[],
+	commands: Array<{ name: string }> = [],
+	getAllToolsThrows = false,
+	getCommandsThrows = false,
+): ExtensionAPI {
+	return {
+		getAllTools: () => {
+			if (getAllToolsThrows) {
+				throw new Error("getAllTools failed");
+			}
+			return allTools;
+		},
+		getCommands: () => {
+			if (getCommandsThrows) {
+				throw new Error("getCommands failed");
+			}
+			return commands;
+		},
+	} as unknown as ExtensionAPI;
+}
+
+function makeMcpTool(name: string, description?: string): unknown {
+	return {
+		name,
+		description: description ?? `MCP wrapper for ${name}`,
+		parameters: {},
+	};
+}
+
+function makeNonMcpTool(name: string): unknown {
+	return {
+		name,
+		description: `Built-in ${name} tool`,
+		parameters: {},
+		execute: () => {},
+	};
+}
+
+function withTempDir(name: string, fn: (dir: string) => void): void {
+	const dir = mkdtempSync(join(tmpdir(), name));
+	try {
+		fn(dir);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+test("returns no capabilities when API is empty", () => {
+	withTempDir("pi-cap-empty-", (dir) => {
+		const oldEnv = process.env.PI_CODING_AGENT_DIR;
+		process.env.PI_CODING_AGENT_DIR = dir;
+		try {
+			const api = createApiStub([], []);
+			const caps = detectToolDisplayCapabilities(api, dir);
+			assert.equal(caps.hasMcpTooling, false);
+			assert.equal(caps.hasRtkOptimizer, false);
+		} finally {
+			if (oldEnv === undefined) {
+				delete process.env.PI_CODING_AGENT_DIR;
+			} else {
+				process.env.PI_CODING_AGENT_DIR = oldEnv;
+			}
+		}
+	});
+});
+
+test("detects MCP capability via isMcpToolCandidate with 'MCP' in description", () => {
+	const api = createApiStub([
+		makeMcpTool("exa_web_search_exa", "Search the web. Direct MCP wrapper for 'exa:web_search_exa'."),
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, true);
+});
+
+test("detects MCP capability via tool named 'mcp'", () => {
+	const api = createApiStub([
+		makeNonMcpTool("read"),
+		{ name: "mcp", description: "MCP proxy", parameters: {} },
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, true);
+});
+
+test("non-MCP tools do not set hasMcpTooling", () => {
+	const api = createApiStub([
+		makeNonMcpTool("read"),
+		makeNonMcpTool("edit"),
+		makeNonMcpTool("bash"),
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, false);
+});
+
+test("handles getAllTools throwing gracefully", () => {
+	const api = createApiStub([], [], true);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, false);
+	// Should still attempt RTK detection
+	assert.equal(typeof caps.hasRtkOptimizer, "boolean");
+});
+
+test("recognises RTK capability via registered command", () => {
+	const api = createApiStub([], [{ name: "rtk" }]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasRtkOptimizer, true);
+});
+
+test("recognises RTK capability via rtk- prefix command", () => {
+	const api = createApiStub([], [{ name: "rtk-compact" }]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasRtkOptimizer, true);
+});
+
+test("handles getCommands throwing gracefully and falls back to path probe", () => {
+	withTempDir("pi-cap-cmd-throw-", (dir) => {
+		const oldEnv = process.env.PI_CODING_AGENT_DIR;
+		process.env.PI_CODING_AGENT_DIR = dir;
+		try {
+			const api = createApiStub([], [], false, true);
+			const caps = detectToolDisplayCapabilities(api, dir);
+			assert.equal(caps.hasRtkOptimizer, false);
+		} finally {
+			if (oldEnv === undefined) {
+				delete process.env.PI_CODING_AGENT_DIR;
+			} else {
+				process.env.PI_CODING_AGENT_DIR = oldEnv;
+			}
+		}
+	});
+});
+
+test("detects RTK extension path when pi-rtk-optimizer exists in agent dir", () => {
+	withTempDir("pi-rtk-test-", (dir) => {
+		const extDir = join(dir, "extensions", "pi-rtk-optimizer");
+		mkdirSync(extDir, { recursive: true });
+
+		const oldEnv = process.env.PI_CODING_AGENT_DIR;
+		process.env.PI_CODING_AGENT_DIR = dir;
+
+		try {
+			const api = createApiStub([], []);
+			const caps = detectToolDisplayCapabilities(api, dir);
+			assert.equal(caps.hasRtkOptimizer, true);
+		} finally {
+			if (oldEnv === undefined) {
+				delete process.env.PI_CODING_AGENT_DIR;
+			} else {
+				process.env.PI_CODING_AGENT_DIR = oldEnv;
+			}
+		}
+	});
+});
+
+test("detects RTK extension via cwd config-dir path", () => {
+	withTempDir("pi-rtk-cwd-", (dir) => {
+		const extDir = join(dir, CONFIG_DIR_NAME, "extensions", "pi-rtk-optimizer");
+		mkdirSync(extDir, { recursive: true });
+
+		const api = createApiStub([], []);
+		const caps = detectToolDisplayCapabilities(api, dir);
+
+		assert.equal(caps.hasRtkOptimizer, true);
+	});
+});
+
+test("no false positive when both commands and path are absent", () => {
+	withTempDir("pi-cap-no-fp-", (dir) => {
+		const oldEnv = process.env.PI_CODING_AGENT_DIR;
+		process.env.PI_CODING_AGENT_DIR = dir;
+		try {
+			const api = createApiStub([], []);
+			const caps = detectToolDisplayCapabilities(api, dir);
+			assert.equal(caps.hasRtkOptimizer, false);
+		} finally {
+			if (oldEnv === undefined) {
+				delete process.env.PI_CODING_AGENT_DIR;
+			} else {
+				process.env.PI_CODING_AGENT_DIR = oldEnv;
+			}
+		}
+	});
+});
+
+test("applyCapabilityConfigGuards preserves MCP output when MCP may appear dynamically", () => {
+	const guarded = applyCapabilityConfigGuards(
+		{ ...DEFAULT_TOOL_DISPLAY_CONFIG, mcpOutputMode: "preview" },
+		{ hasMcpTooling: false, hasRtkOptimizer: true },
+	);
+
+	assert.equal(guarded.mcpOutputMode, "preview");
+	assert.equal(guarded.showRtkCompactionHints, DEFAULT_TOOL_DISPLAY_CONFIG.showRtkCompactionHints);
+});
+
+test("applyCapabilityConfigGuards disables RTK hints when RTK unavailable", () => {
+	const guarded = applyCapabilityConfigGuards(
+		{ ...DEFAULT_TOOL_DISPLAY_CONFIG, showRtkCompactionHints: true },
+		{ hasMcpTooling: true, hasRtkOptimizer: false },
+	);
+
+	assert.equal(guarded.mcpOutputMode, DEFAULT_TOOL_DISPLAY_CONFIG.mcpOutputMode);
+	assert.equal(guarded.showRtkCompactionHints, false);
+});
+
+test("applyCapabilityConfigGuards preserves values when both capabilities present", () => {
+	const input = {
+		...DEFAULT_TOOL_DISPLAY_CONFIG,
+		mcpOutputMode: "preview" as const,
+		showRtkCompactionHints: true,
+	};
+	const guarded = applyCapabilityConfigGuards(input, {
+		hasMcpTooling: true,
+		hasRtkOptimizer: true,
+	});
+
+	assert.equal(guarded.mcpOutputMode, "preview");
+	assert.equal(guarded.showRtkCompactionHints, true);
+});
+
+test("applyCapabilityConfigGuards clones registerToolOverrides", () => {
+	const input = { ...DEFAULT_TOOL_DISPLAY_CONFIG };
+	const guarded = applyCapabilityConfigGuards(input, {
+		hasMcpTooling: false,
+		hasRtkOptimizer: false,
+	});
+
+	// Modifying the source should not affect the guarded copy
+	const originalOverrides = input.registerToolOverrides;
+	const guardedOverrides = guarded.registerToolOverrides;
+	assert.notEqual(originalOverrides, guardedOverrides, "should be a different object");
+	assert.deepEqual(originalOverrides, guardedOverrides);
+});
+
+// #6: PI_CODING_AGENT_DIR support — env var changes affect RTK path probe
+test("PI_CODING_AGENT_DIR influences RTK extension path detection", () => {
+	withTempDir("pi-coding-agent-dir-", (dir) => {
+		// Create the expected rtk-optimizer path inside a custom agent dir
+		const extDir = join(dir, "extensions", "pi-rtk-optimizer");
+		mkdirSync(extDir, { recursive: true });
+
+		const previousEnv = process.env.PI_CODING_AGENT_DIR;
+		process.env.PI_CODING_AGENT_DIR = dir;
+
+		try {
+			const api = createApiStub([], []);
+			const caps = detectToolDisplayCapabilities(api, dir);
+			assert.equal(caps.hasRtkOptimizer, true, "PI_CODING_AGENT_DIR should point to dir with rtk-optimizer");
+		} finally {
+			if (previousEnv === undefined) {
+				delete process.env.PI_CODING_AGENT_DIR;
+			} else {
+				process.env.PI_CODING_AGENT_DIR = previousEnv;
+			}
+		}
+	});
+});
+
+test("PI_CODING_AGENT_DIR set to dir without rtk-optimizer yields no RTK capability", () => {
+	withTempDir("pi-cap-no-rtk-", (dir) => {
+		const oldEnv = process.env.PI_CODING_AGENT_DIR;
+		process.env.PI_CODING_AGENT_DIR = dir;
+		try {
+			const api = createApiStub([], []);
+			const caps = detectToolDisplayCapabilities(api, dir);
+			assert.equal(caps.hasRtkOptimizer, false, "dir without rtk-optimizer should yield false");
+		} finally {
+			if (oldEnv === undefined) {
+				delete process.env.PI_CODING_AGENT_DIR;
+			} else {
+				process.env.PI_CODING_AGENT_DIR = oldEnv;
+			}
+		}
+	});
+});
+
+// #20: peer dependency compatibility — missing/renamed APIs
+test("tools without description do not trigger false MCP detection", () => {
+	const api = createApiStub([
+		{ name: "custom-tool", parameters: {} },
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, false);
+});
+
+test("tools with 'MCP' in the description but no MCP-like name are detected", () => {
+	const api = createApiStub([
+		{
+			name: "random_tool",
+			description: "This uses the MCP protocol for communication with external servers.",
+			parameters: {},
+		},
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, true);
+});
+
+test("tool with empty name string is handled safely", () => {
+	const api = createApiStub([
+		{ name: "", description: "empty name tool", parameters: {} },
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, false);
+});
+
+test("tool with undefined name is handled safely", () => {
+	const api = createApiStub([
+		{ description: "no name field", parameters: {} },
+	]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, false);
+});
+
+test("commands list can contain non-string name entries", () => {
+	const api = createApiStub(
+		[],
+		// @ts-expect-error testing edge case
+		[{ name: 123 }, { name: "rtk" }],
+	);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasRtkOptimizer, true);
+});
+
+test("empty allTools array does not throw", () => {
+	const api = createApiStub([]);
+	const caps = detectToolDisplayCapabilities(api, "/tmp");
+
+	assert.equal(caps.hasMcpTooling, false);
+});

package/dist/extensions/pi-tool-display/tests/capabilities.test.ts

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import {
+	applyCapabilityConfigGuards,
+	detectToolDisplayCapabilities,
+} from "../src/capabilities.ts";
+import { DEFAULT_TOOL_DISPLAY_CONFIG } from "../src/types.ts";
+
+function createExtensionApiStub(allTools: unknown[]): ExtensionAPI {
+	return {
+		getAllTools(): unknown[] {
+			return allTools;
+		},
+		getCommands(): Array<{ name: string }> {
+			return [];
+		},
+	} as unknown as ExtensionAPI;
+}
+
+test("detectToolDisplayCapabilities recognises MCP tools from v0.62.0 tool info without label or execute", () => {
+	const api = createExtensionApiStub([
+		{
+			name: "exa_web_search_exa",
+			description:
+				"Search the web with Exa. Direct MCP wrapper for 'exa:web_search_exa'. Common args: query*.",
+			parameters: {},
+			sourceInfo: {
+				path: "C:/Users/Administrator/.pi/agent/extensions/pi-mcp-adapter/index.ts",
+				source: "local",
+				scope: "user",
+				origin: "top-level",
+			},
+		},
+	]);
+
+	const capabilities = detectToolDisplayCapabilities(api, `C:/Users/Administrator/${CONFIG_DIR_NAME}`);
+
+	assert.equal(capabilities.hasMcpTooling, true);
+});
+
+test("applyCapabilityConfigGuards preserves MCP output when MCP tooling is not detected yet", () => {
+	const guarded = applyCapabilityConfigGuards(
+		{ ...DEFAULT_TOOL_DISPLAY_CONFIG, mcpOutputMode: "preview" },
+		{
+			hasMcpTooling: false,
+			hasRtkOptimizer: true,
+		},
+	);
+
+	assert.equal(guarded.mcpOutputMode, "preview");
+	assert.equal(guarded.showRtkCompactionHints, DEFAULT_TOOL_DISPLAY_CONFIG.showRtkCompactionHints);
+});