@asterxsk/kiln 0.4.0 → 0.4.2

package/agent/extensions/pi-web-access/test/summary-model-scope.test.mjs

@@ -1,106 +1,106 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-
-import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns } from "../summary-model-scope.ts";
-
-const queryRewriteSrc = readFileSync(new URL("../query-rewrite.ts", import.meta.url), "utf8");
-
-test("summary model scope matches nested provider model ids and thinking suffixes", () => {
-	assert.equal(
-		modelMatchesEnabledPatterns(
-			{ provider: "openrouter", id: "nvidia/nemotron-3-super-120b-a12b:free" },
-			["openrouter/nvidia/nemotron-3-super-120b-a12b:free"],
-		),
-		true,
-	);
-	assert.equal(
-		modelMatchesEnabledPatterns(
-			{ provider: "openrouter", id: "anthropic/claude-sonnet-4" },
-			["openrouter/*:low"],
-		),
-		true,
-	);
-	assert.equal(
-		modelMatchesEnabledPatterns(
-			{ provider: "openrouter", id: "ai21/jamba-large-1.7" },
-			["openrouter/nvidia/*"],
-		),
-		false,
-	);
-});
-
-test("preferred models resolve through routed providers", () => {
-	const routedModel = { provider: "openrouter", id: "anthropic/claude-haiku-4-5" };
-	const registry = {
-		find: () => undefined,
-		getAvailable: () => [routedModel],
-	};
-
-	assert.equal(
-		findModelWithProviderRouting(registry, "anthropic", "claude-haiku-4-5"),
-		routedModel,
-	);
-});
-
-test("model resolution preserves the direct registry fallback", () => {
-	const configuredModel = { provider: "anthropic", id: "claude-haiku-4-5" };
-	const registry = {
-		find: () => configuredModel,
-		getAvailable: () => [],
-	};
-
-	assert.equal(
-		findModelWithProviderRouting(registry, "anthropic", "claude-haiku-4-5"),
-		configuredModel,
-	);
-});
-
-test("routed model resolution follows available-model ordering", () => {
-	const firstRoute = { provider: "openrouter", id: "anthropic/claude-haiku-4-5" };
-	const secondRoute = { provider: "requesty", id: "anthropic/claude-haiku-4-5" };
-	const registry = {
-		find: () => undefined,
-		getAvailable: () => [firstRoute, secondRoute],
-	};
-
-	assert.equal(
-		findModelWithProviderRouting(registry, "anthropic", "claude-haiku-4-5"),
-		firstRoute,
-	);
-});
-
-test("enabledModels loading uses trusted project settings over global settings", async () => {
-	const agentDir = await mkdtemp(join(tmpdir(), "pi-web-access-agent-"));
-	const projectDir = await mkdtemp(join(tmpdir(), "pi-web-access-project-"));
-	await writeFile(join(agentDir, "settings.json"), JSON.stringify({ enabledModels: ["global/model"] }));
-	await mkdir(join(projectDir, ".pi"));
-	await writeFile(join(projectDir, ".pi", "settings.json"), JSON.stringify({ enabledModels: ["project/model"] }));
-
-	const previous = process.env.PI_CODING_AGENT_DIR;
-	process.env.PI_CODING_AGENT_DIR = agentDir;
-	try {
-		assert.deepEqual(
-			loadEnabledModelPatterns({ cwd: projectDir, isProjectTrusted: () => true }),
-			["project/model"],
-		);
-		assert.deepEqual(
-			loadEnabledModelPatterns({ cwd: projectDir, isProjectTrusted: () => false }),
-			["global/model"],
-		);
-	} finally {
-		if (previous === undefined) {
-			delete process.env.PI_CODING_AGENT_DIR;
-		} else {
-			process.env.PI_CODING_AGENT_DIR = previous;
-		}
-	}
-});
-
-test("query rewrite defaults use the refreshed model order", () => {
-	assert.match(queryRewriteSrc, /id: "gpt-5-mini"/);
-	assert.doesNotMatch(queryRewriteSrc, /gpt-4\.1-mini/);
-});
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns } from "../summary-model-scope.ts";
+
+const queryRewriteSrc = readFileSync(new URL("../query-rewrite.ts", import.meta.url), "utf8");
+
+test("summary model scope matches nested provider model ids and thinking suffixes", () => {
+	assert.equal(
+		modelMatchesEnabledPatterns(
+			{ provider: "openrouter", id: "nvidia/nemotron-3-super-120b-a12b:free" },
+			["openrouter/nvidia/nemotron-3-super-120b-a12b:free"],
+		),
+		true,
+	);
+	assert.equal(
+		modelMatchesEnabledPatterns(
+			{ provider: "openrouter", id: "anthropic/claude-sonnet-4" },
+			["openrouter/*:low"],
+		),
+		true,
+	);
+	assert.equal(
+		modelMatchesEnabledPatterns(
+			{ provider: "openrouter", id: "ai21/jamba-large-1.7" },
+			["openrouter/nvidia/*"],
+		),
+		false,
+	);
+});
+
+test("preferred models resolve through routed providers", () => {
+	const routedModel = { provider: "openrouter", id: "anthropic/claude-haiku-4-5" };
+	const registry = {
+		find: () => undefined,
+		getAvailable: () => [routedModel],
+	};
+
+	assert.equal(
+		findModelWithProviderRouting(registry, "anthropic", "claude-haiku-4-5"),
+		routedModel,
+	);
+});
+
+test("model resolution preserves the direct registry fallback", () => {
+	const configuredModel = { provider: "anthropic", id: "claude-haiku-4-5" };
+	const registry = {
+		find: () => configuredModel,
+		getAvailable: () => [],
+	};
+
+	assert.equal(
+		findModelWithProviderRouting(registry, "anthropic", "claude-haiku-4-5"),
+		configuredModel,
+	);
+});
+
+test("routed model resolution follows available-model ordering", () => {
+	const firstRoute = { provider: "openrouter", id: "anthropic/claude-haiku-4-5" };
+	const secondRoute = { provider: "requesty", id: "anthropic/claude-haiku-4-5" };
+	const registry = {
+		find: () => undefined,
+		getAvailable: () => [firstRoute, secondRoute],
+	};
+
+	assert.equal(
+		findModelWithProviderRouting(registry, "anthropic", "claude-haiku-4-5"),
+		firstRoute,
+	);
+});
+
+test("enabledModels loading uses trusted project settings over global settings", async () => {
+	const agentDir = await mkdtemp(join(tmpdir(), "pi-web-access-agent-"));
+	const projectDir = await mkdtemp(join(tmpdir(), "pi-web-access-project-"));
+	await writeFile(join(agentDir, "settings.json"), JSON.stringify({ enabledModels: ["global/model"] }));
+	await mkdir(join(projectDir, ".pi"));
+	await writeFile(join(projectDir, ".pi", "settings.json"), JSON.stringify({ enabledModels: ["project/model"] }));
+
+	const previous = process.env.PI_CODING_AGENT_DIR;
+	process.env.PI_CODING_AGENT_DIR = agentDir;
+	try {
+		assert.deepEqual(
+			loadEnabledModelPatterns({ cwd: projectDir, isProjectTrusted: () => true }),
+			["project/model"],
+		);
+		assert.deepEqual(
+			loadEnabledModelPatterns({ cwd: projectDir, isProjectTrusted: () => false }),
+			["global/model"],
+		);
+	} finally {
+		if (previous === undefined) {
+			delete process.env.PI_CODING_AGENT_DIR;
+		} else {
+			process.env.PI_CODING_AGENT_DIR = previous;
+		}
+	}
+});
+
+test("query rewrite defaults use the refreshed model order", () => {
+	assert.match(queryRewriteSrc, /id: "gpt-5-mini"/);
+	assert.doesNotMatch(queryRewriteSrc, /gpt-4\.1-mini/);
+});

package/agent/extensions/pi-web-access/test/tool-registration-config.test.mjs

@@ -1,182 +1,182 @@
-import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { Value } from "typebox/value";
-
-import initializeExtension from "../index.ts";
-
-const indexUrl = new URL("../index.ts", import.meta.url).href;
-const indexSrc = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
-const readmeSrc = readFileSync(new URL("../README.md", import.meta.url), "utf8");
-
-function runRegistration(config) {
-	return runRegistrationWithConfig(JSON.stringify(config) + "\n");
-}
-
-function runRegistrationWithConfig(configText) {
-	const root = mkdtempSync(join(tmpdir(), "pi-web-access-tool-names-"));
-	writeFileSync(join(root, "web-search.json"), configText, "utf8");
-	return spawnSync(process.execPath, ["--input-type=module"], {
-		input: `
-			const { default: initializeExtension } = await import(${JSON.stringify(indexUrl)});
-			const tools = [];
-			const commands = [];
-			initializeExtension({
-				registerTool(tool) { tools.push({ name: tool.name, description: tool.description, promptSnippet: tool.promptSnippet, parameters: tool.parameters }); },
-				registerCommand(name) { commands.push(name); },
-				registerShortcut() {},
-				on() {},
-			});
-			console.log(JSON.stringify({ tools, commands }));
-		`,
-		encoding: "utf8",
-		env: { ...process.env, PI_CODING_AGENT_DIR: root, XDG_CONFIG_HOME: "", HOME: join(root, "home"), USERPROFILE: join(root, "home") },
-	});
-}
-
-function registered(config) {
-	const child = runRegistration(config);
-	assert.equal(child.status, 0, child.stderr);
-	return JSON.parse(child.stdout);
-}
-
-function registeredToolNames(config) {
-	return registered(config).tools.map(tool => tool.name);
-}
-
-function registeredTool(config, name) {
-	return registered(config).tools.find(tool => tool.name === name);
-}
-
-function registeredCommandNames(config) {
-	return registered(config).commands;
-}
-
-function registrationError(config) {
-	const child = runRegistration(config);
-	assert.notEqual(child.status, 0, child.stdout);
-	return child.stderr;
-}
-
-test("malformed config falls back during extension registration", () => {
-	const child = runRegistrationWithConfig("{");
-	assert.equal(child.status, 0, child.stderr);
-	const registered = JSON.parse(child.stdout);
-	assert.deepEqual(registered.tools.map(tool => tool.name), ["web_search", "source_check", "fetch_content", "get_search_content"]);
-});
-
-test("search tools constrain numResults to integer values from 1 through 20", () => {
-	for (const name of ["web_search", "source_check"]) {
-		const schema = registeredTool({}, name).parameters.properties.numResults;
-		assert.equal(schema.type, "integer");
-		assert.equal(schema.minimum, 1);
-		assert.equal(schema.maximum, 20);
-		for (const value of [0, -1, 1.5, 21, Number.NaN, Number.POSITIVE_INFINITY]) {
-			assert.equal(Value.Check(schema, value), false, `${name} accepts ${value}`);
-		}
-		for (const value of [1, 5, 20]) {
-			assert.equal(Value.Check(schema, value), true, `${name} rejects ${value}`);
-		}
-	}
-});
-
-test("tool registration gates support legacy and per-tool config", () => {
-	assert.deepEqual(registeredToolNames({ webSearch: { enabled: false } }), ["fetch_content", "get_search_content"]);
-	assert.deepEqual(registeredToolNames({
-		webSearch: { enabled: false },
-		tools: { webSearch: { enabled: true }, sourceCheck: { enabled: true }, fetchContent: { enabled: false } },
-	}), ["web_search", "source_check", "get_search_content"]);
-	assert.deepEqual(registeredToolNames({
-		tools: { sourceCheck: { enabled: false }, getSearchContent: { enabled: false } },
-	}), ["web_search", "fetch_content"]);
-});
-
-test("command registration gates default to enabled", () => {
-	assert.deepEqual(registeredCommandNames({}), ["google-account", "search"]);
-	assert.deepEqual(registeredCommandNames({
-		commands: { websearch: { enabled: false }, search: { enabled: false } },
-	}), ["google-account"]);
-});
-
-test("fetch_content schema exposes auth profile opt-in", () => {
-	const schema = registeredTool({}, "fetch_content").parameters.properties.auth;
-	assert.ok(schema);
-	assert.deepEqual(schema.anyOf.map(option => option.type), ["string", "boolean"]);
-});
-
-test("registered tools do not advertise disabled get_search_content", () => {
-	const fetchTool = registeredTool({ tools: { getSearchContent: { enabled: false } } }, "fetch_content");
-	assert.ok(fetchTool);
-	assert.doesNotMatch(fetchTool.description, /get_search_content/);
-	assert.match(fetchTool.description, /retrieval tool is not registered/);
-});
-
-test("web activity shortcut renders through the supported string-array API", async () => {
-	const shortcuts = [];
-	initializeExtension({
-		registerTool() {},
-		registerCommand() {},
-		registerShortcut(name, shortcut) { shortcuts.push({ name, shortcut }); },
-		on() {},
-	});
-
-	const activityShortcut = shortcuts.find(({ shortcut }) => shortcut.description === "Toggle web search activity");
-	assert.ok(activityShortcut, "activity shortcut was not registered");
-	const widgets = [];
-	const ctx = {
-		ui: {
-			theme: { fg: (_color, text) => text },
-			setWidget(key, content) { widgets.push({ key, content }); },
-		},
-	};
-
-	await activityShortcut.shortcut.handler(ctx);
-	assert.equal(widgets[0].key, "web-activity");
-	assert.ok(Array.isArray(widgets[0].content), "activity widget content must be a string array");
-	assert.ok(widgets[0].content.length > 0);
-
-	await activityShortcut.shortcut.handler(ctx);
-});
-
-test("tool names can be configured without changing defaults", () => {
-	assert.deepEqual(registeredToolNames({}), ["web_search", "source_check", "fetch_content", "get_search_content"]);
-	assert.deepEqual(registeredToolNames({
-		toolNames: {
-			webSearch: "research_web",
-			sourceCheck: "verify_sources",
-			fetchContent: "grab_content",
-			getSearchContent: "open_content",
-		},
-	}), ["research_web", "verify_sources", "grab_content", "open_content"]);
-});
-
-test("tool name config rejects invalid and duplicate registered names", () => {
-	assert.match(registrationError({ toolNames: { webSearch: "1bad" } }), /toolNames\.webSearch/);
-	assert.match(registrationError({ toolNames: { webSearch: "same_name", fetchContent: "same_name" } }), /duplicates/);
-});
-
-test("webSearch.enabled false registers only fetch tools and ignores disabled-name duplicates", () => {
-	assert.deepEqual(registeredToolNames({
-		webSearch: { enabled: false },
-		toolNames: {
-			webSearch: "content_only",
-			sourceCheck: "content_only",
-			fetchContent: "grab_content",
-			getSearchContent: "open_content",
-		},
-	}), ["grab_content", "open_content"]);
-	assert.match(registrationError({
-		webSearch: { enabled: false },
-		toolNames: { fetchContent: "same_name", getSearchContent: "same_name" },
-	}), /duplicates/);
-});
-
-test("README documents registration gates and toolNames", () => {
-	assert.match(readmeSrc, /"tools": \{/);
-	assert.match(readmeSrc, /"commands": \{/);
-	assert.match(readmeSrc, /Pi restart is required for tool and command registration changes/);
-	assert.match(readmeSrc, /`toolNames` can opt into alternate public tool names/);
-});
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { Value } from "typebox/value";
+
+import initializeExtension from "../index.ts";
+
+const indexUrl = new URL("../index.ts", import.meta.url).href;
+const indexSrc = readFileSync(new URL("../index.ts", import.meta.url), "utf8");
+const readmeSrc = readFileSync(new URL("../README.md", import.meta.url), "utf8");
+
+function runRegistration(config) {
+	return runRegistrationWithConfig(JSON.stringify(config) + "\n");
+}
+
+function runRegistrationWithConfig(configText) {
+	const root = mkdtempSync(join(tmpdir(), "pi-web-access-tool-names-"));
+	writeFileSync(join(root, "web-search.json"), configText, "utf8");
+	return spawnSync(process.execPath, ["--input-type=module"], {
+		input: `
+			const { default: initializeExtension } = await import(${JSON.stringify(indexUrl)});
+			const tools = [];
+			const commands = [];
+			initializeExtension({
+				registerTool(tool) { tools.push({ name: tool.name, description: tool.description, promptSnippet: tool.promptSnippet, parameters: tool.parameters }); },
+				registerCommand(name) { commands.push(name); },
+				registerShortcut() {},
+				on() {},
+			});
+			console.log(JSON.stringify({ tools, commands }));
+		`,
+		encoding: "utf8",
+		env: { ...process.env, PI_CODING_AGENT_DIR: root, XDG_CONFIG_HOME: "", HOME: join(root, "home"), USERPROFILE: join(root, "home") },
+	});
+}
+
+function registered(config) {
+	const child = runRegistration(config);
+	assert.equal(child.status, 0, child.stderr);
+	return JSON.parse(child.stdout);
+}
+
+function registeredToolNames(config) {
+	return registered(config).tools.map(tool => tool.name);
+}
+
+function registeredTool(config, name) {
+	return registered(config).tools.find(tool => tool.name === name);
+}
+
+function registeredCommandNames(config) {
+	return registered(config).commands;
+}
+
+function registrationError(config) {
+	const child = runRegistration(config);
+	assert.notEqual(child.status, 0, child.stdout);
+	return child.stderr;
+}
+
+test("malformed config falls back during extension registration", () => {
+	const child = runRegistrationWithConfig("{");
+	assert.equal(child.status, 0, child.stderr);
+	const registered = JSON.parse(child.stdout);
+	assert.deepEqual(registered.tools.map(tool => tool.name), ["web_search", "source_check", "fetch_content", "get_search_content"]);
+});
+
+test("search tools constrain numResults to integer values from 1 through 20", () => {
+	for (const name of ["web_search", "source_check"]) {
+		const schema = registeredTool({}, name).parameters.properties.numResults;
+		assert.equal(schema.type, "integer");
+		assert.equal(schema.minimum, 1);
+		assert.equal(schema.maximum, 20);
+		for (const value of [0, -1, 1.5, 21, Number.NaN, Number.POSITIVE_INFINITY]) {
+			assert.equal(Value.Check(schema, value), false, `${name} accepts ${value}`);
+		}
+		for (const value of [1, 5, 20]) {
+			assert.equal(Value.Check(schema, value), true, `${name} rejects ${value}`);
+		}
+	}
+});
+
+test("tool registration gates support legacy and per-tool config", () => {
+	assert.deepEqual(registeredToolNames({ webSearch: { enabled: false } }), ["fetch_content", "get_search_content"]);
+	assert.deepEqual(registeredToolNames({
+		webSearch: { enabled: false },
+		tools: { webSearch: { enabled: true }, sourceCheck: { enabled: true }, fetchContent: { enabled: false } },
+	}), ["web_search", "source_check", "get_search_content"]);
+	assert.deepEqual(registeredToolNames({
+		tools: { sourceCheck: { enabled: false }, getSearchContent: { enabled: false } },
+	}), ["web_search", "fetch_content"]);
+});
+
+test("command registration gates default to enabled", () => {
+	assert.deepEqual(registeredCommandNames({}), ["google-account", "search"]);
+	assert.deepEqual(registeredCommandNames({
+		commands: { websearch: { enabled: false }, search: { enabled: false } },
+	}), ["google-account"]);
+});
+
+test("fetch_content schema exposes auth profile opt-in", () => {
+	const schema = registeredTool({}, "fetch_content").parameters.properties.auth;
+	assert.ok(schema);
+	assert.deepEqual(schema.anyOf.map(option => option.type), ["string", "boolean"]);
+});
+
+test("registered tools do not advertise disabled get_search_content", () => {
+	const fetchTool = registeredTool({ tools: { getSearchContent: { enabled: false } } }, "fetch_content");
+	assert.ok(fetchTool);
+	assert.doesNotMatch(fetchTool.description, /get_search_content/);
+	assert.match(fetchTool.description, /retrieval tool is not registered/);
+});
+
+test("web activity shortcut renders through the supported string-array API", async () => {
+	const shortcuts = [];
+	initializeExtension({
+		registerTool() {},
+		registerCommand() {},
+		registerShortcut(name, shortcut) { shortcuts.push({ name, shortcut }); },
+		on() {},
+	});
+
+	const activityShortcut = shortcuts.find(({ shortcut }) => shortcut.description === "Toggle web search activity");
+	assert.ok(activityShortcut, "activity shortcut was not registered");
+	const widgets = [];
+	const ctx = {
+		ui: {
+			theme: { fg: (_color, text) => text },
+			setWidget(key, content) { widgets.push({ key, content }); },
+		},
+	};
+
+	await activityShortcut.shortcut.handler(ctx);
+	assert.equal(widgets[0].key, "web-activity");
+	assert.ok(Array.isArray(widgets[0].content), "activity widget content must be a string array");
+	assert.ok(widgets[0].content.length > 0);
+
+	await activityShortcut.shortcut.handler(ctx);
+});
+
+test("tool names can be configured without changing defaults", () => {
+	assert.deepEqual(registeredToolNames({}), ["web_search", "source_check", "fetch_content", "get_search_content"]);
+	assert.deepEqual(registeredToolNames({
+		toolNames: {
+			webSearch: "research_web",
+			sourceCheck: "verify_sources",
+			fetchContent: "grab_content",
+			getSearchContent: "open_content",
+		},
+	}), ["research_web", "verify_sources", "grab_content", "open_content"]);
+});
+
+test("tool name config rejects invalid and duplicate registered names", () => {
+	assert.match(registrationError({ toolNames: { webSearch: "1bad" } }), /toolNames\.webSearch/);
+	assert.match(registrationError({ toolNames: { webSearch: "same_name", fetchContent: "same_name" } }), /duplicates/);
+});
+
+test("webSearch.enabled false registers only fetch tools and ignores disabled-name duplicates", () => {
+	assert.deepEqual(registeredToolNames({
+		webSearch: { enabled: false },
+		toolNames: {
+			webSearch: "content_only",
+			sourceCheck: "content_only",
+			fetchContent: "grab_content",
+			getSearchContent: "open_content",
+		},
+	}), ["grab_content", "open_content"]);
+	assert.match(registrationError({
+		webSearch: { enabled: false },
+		toolNames: { fetchContent: "same_name", getSearchContent: "same_name" },
+	}), /duplicates/);
+});
+
+test("README documents registration gates and toolNames", () => {
+	assert.match(readmeSrc, /"tools": \{/);
+	assert.match(readmeSrc, /"commands": \{/);
+	assert.match(readmeSrc, /Pi restart is required for tool and command registration changes/);
+	assert.match(readmeSrc, /`toolNames` can opt into alternate public tool names/);
+});