@clinebot/core 0.0.34 → 0.0.36

package/src/tools/executors/bash.test.ts

@@ -1,87 +0,0 @@
-import type { ToolContext } from "@clinebot/shared";
-import { describe, expect, it } from "vitest";
-import { createBashExecutor } from "./bash";
-
-const ctx: ToolContext = {
-	agentId: "agent-1",
-	conversationId: "conv-1",
-	iteration: 1,
-};
-
-describe("createBashExecutor", () => {
-	it("runs a simple command and returns stdout", async () => {
-		const bash = createBashExecutor();
-		const output = await bash("echo hello", process.cwd(), ctx);
-		expect(output.trim()).toBe("hello");
-	});
-
-	it("rejects on non-zero exit code", async () => {
-		const bash = createBashExecutor();
-		await expect(bash("exit 1", process.cwd(), ctx)).rejects.toThrow();
-	});
-
-	it("includes stderr in combined output on success", async () => {
-		const bash = createBashExecutor({ combineOutput: true });
-		const cmd = `${process.execPath} -e "process.stdout.write('ok'); process.stderr.write('warn')"`;
-		const output = await bash(cmd, process.cwd(), ctx);
-		expect(output).toContain("ok");
-		expect(output).toContain("[stderr]");
-		expect(output).toContain("warn");
-	});
-
-	it("excludes stderr when combineOutput is false", async () => {
-		const bash = createBashExecutor({ combineOutput: false });
-		const cmd = `${process.execPath} -e "process.stdout.write('ok'); process.stderr.write('warn')"`;
-		const output = await bash(cmd, process.cwd(), ctx);
-		expect(output.trim()).toBe("ok");
-	});
-
-	it("rejects on timeout", async () => {
-		const bash = createBashExecutor({ timeoutMs: 50 });
-		await expect(bash("sleep 10", process.cwd(), ctx)).rejects.toThrow(
-			"timed out",
-		);
-	});
-
-	it("truncates output exceeding maxOutputBytes", async () => {
-		const bash = createBashExecutor({ maxOutputBytes: 10 });
-		const output = await bash(
-			`${process.execPath} -e "process.stdout.write('a'.repeat(100))"`,
-			process.cwd(),
-			ctx,
-		);
-		expect(output).toContain("[Output truncated:");
-	});
-
-	it("rejects when abort signal fires", async () => {
-		const ac = new AbortController();
-		const abortCtx: ToolContext = { ...ctx, abortSignal: ac.signal };
-		const bash = createBashExecutor();
-
-		setTimeout(() => ac.abort(), 50);
-		await expect(bash("sleep 10", process.cwd(), abortCtx)).rejects.toThrow(
-			"aborted",
-		);
-	});
-});
-
-describe.runIf(process.platform === "win32")("createWindowsExecutor", () => {
-	it("runs structured commands without shell parsing", async () => {
-		const executor = createBashExecutor();
-		const output = await executor(
-			{
-				command: process.execPath,
-				args: ["-e", "process.stdout.write(process.argv[1])", "argv-ok"],
-			},
-			process.cwd(),
-			ctx,
-		);
-		expect(output).toBe("argv-ok");
-	});
-
-	it("runs string commands through the shell", async () => {
-		const executor = createBashExecutor();
-		const output = await executor("echo shell-ok", process.cwd(), ctx);
-		expect(output.trim()).toBe("shell-ok");
-	});
-});

package/src/tools/executors/editor.test.ts

@@ -1,35 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, expect, it } from "vitest";
-import { createEditorExecutor } from "./editor";
-
-describe("createEditorExecutor", () => {
-	it("creates a missing file when edit is used", async () => {
-		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
-		const filePath = path.join(dir, "example.txt");
-
-		try {
-			const editor = createEditorExecutor();
-			const result = await editor(
-				{
-					path: filePath,
-					new_text: "created with edit",
-				},
-				dir,
-				{
-					agentId: "agent-1",
-					conversationId: "conv-1",
-					iteration: 1,
-				},
-			);
-
-			expect(result).toBe(`File created successfully at: ${filePath}`);
-			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
-				"created with edit",
-			);
-		} finally {
-			await fs.rm(dir, { recursive: true, force: true });
-		}
-	});
-});

package/src/tools/executors/file-read.test.ts

@@ -1,49 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, expect, it } from "vitest";
-import { createFileReadExecutor } from "./file-read";
-
-describe("createFileReadExecutor", () => {
-	it("reads a file from an absolute path", async () => {
-		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
-		const filePath = path.join(dir, "example.txt");
-		await fs.writeFile(filePath, "hello absolute path", "utf-8");
-
-		try {
-			const readFile = createFileReadExecutor();
-			const result = await readFile(
-				{ path: filePath },
-				{
-					agentId: "agent-1",
-					conversationId: "conv-1",
-					iteration: 1,
-				},
-			);
-			expect(result).toBe("1 | hello absolute path");
-		} finally {
-			await fs.rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("returns only the requested inclusive line range", async () => {
-		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
-		const filePath = path.join(dir, "example.txt");
-		await fs.writeFile(filePath, "alpha\nbeta\ngamma\ndelta", "utf-8");
-
-		try {
-			const readFile = createFileReadExecutor();
-			const result = await readFile(
-				{ path: filePath, start_line: 2, end_line: 3 },
-				{
-					agentId: "agent-1",
-					conversationId: "conv-1",
-					iteration: 1,
-				},
-			);
-			expect(result).toBe("2 | beta\n3 | gamma");
-		} finally {
-			await fs.rm(dir, { recursive: true, force: true });
-		}
-	});
-});

package/src/tools/model-tool-routing.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	DEFAULT_MODEL_TOOL_ROUTING_RULES,
-	resolveToolRoutingConfig,
-} from "./model-tool-routing";
-
-describe("model tool routing", () => {
-	it("applies default codex/gpt routing in act mode", () => {
-		const config = resolveToolRoutingConfig(
-			"openai",
-			"openai/gpt-5.4",
-			"act",
-			DEFAULT_MODEL_TOOL_ROUTING_RULES,
-		);
-
-		expect(config.enableApplyPatch).toBe(true);
-		expect(config.enableEditor).toBe(false);
-	});
-
-	it("does not apply default codex/gpt routing in plan mode", () => {
-		const config = resolveToolRoutingConfig(
-			"openai",
-			"openai/gpt-5.4",
-			"plan",
-			DEFAULT_MODEL_TOOL_ROUTING_RULES,
-		);
-
-		expect(config).toEqual({});
-	});
-
-	it("applies matching custom rules in order", () => {
-		const config = resolveToolRoutingConfig(
-			"anthropic",
-			"claude-sonnet-4-6",
-			"act",
-			[
-				{
-					name: "claude-editor-off",
-					mode: "act",
-					modelIdIncludes: ["claude"],
-					disableTools: ["editor"],
-				},
-				{
-					name: "claude-apply-patch-on",
-					mode: "act",
-					modelIdIncludes: ["claude"],
-					enableTools: ["apply_patch"],
-				},
-			],
-		);
-
-		expect(config.enableEditor).toBe(false);
-		expect(config.enableApplyPatch).toBe(true);
-	});
-
-	it("returns empty config when no rules match", () => {
-		const config = resolveToolRoutingConfig(
-			"anthropic",
-			"claude-sonnet-4-6",
-			"act",
-			[
-				{
-					mode: "act",
-					modelIdIncludes: ["gpt"],
-					enableTools: ["apply_patch"],
-				},
-			],
-		);
-
-		expect(config).toEqual({});
-	});
-
-	it("can match provider-only rules", () => {
-		const config = resolveToolRoutingConfig("openai", "o4-mini", "act", [
-			{
-				mode: "act",
-				providerIdIncludes: ["openai"],
-				enableTools: ["apply_patch"],
-				disableTools: ["editor"],
-			},
-		]);
-
-		expect(config.enableApplyPatch).toBe(true);
-		expect(config.enableEditor).toBe(false);
-	});
-});

package/src/tools/presets.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	createDefaultToolsWithPreset,
-	createToolPoliciesWithPreset,
-	ToolPresets,
-} from "./presets";
-
-describe("default tool presets", () => {
-	it("explicitly configures ask_question across presets", () => {
-		expect(ToolPresets.search.enableAskQuestion).toBe(false);
-		expect(ToolPresets.development.enableAskQuestion).toBe(true);
-		expect(ToolPresets.readonly.enableAskQuestion).toBe(true);
-		expect(ToolPresets.minimal.enableAskQuestion).toBe(true);
-		expect(ToolPresets.yolo.enableAskQuestion).toBe(false);
-	});
-
-	it("disables spawn and team tools by default in yolo mode", () => {
-		expect(ToolPresets.development.enableSpawnAgent).toBe(true);
-		expect(ToolPresets.development.enableAgentTeams).toBe(true);
-		expect(ToolPresets.yolo.enableSpawnAgent).toBe(false);
-		expect(ToolPresets.yolo.enableAgentTeams).toBe(false);
-		expect(ToolPresets.yolo.enableSubmitAndExit).toBe(true);
-	});
-
-	it("yolo preset excludes ask_question even when its executor exists", () => {
-		const tools = createDefaultToolsWithPreset("yolo", {
-			executors: {
-				readFile: async () => "ok",
-				search: async () => "ok",
-				bash: async () => "ok",
-				webFetch: async () => "ok",
-				applyPatch: async () => "ok",
-				editor: async () => "ok",
-				skills: async () => "ok",
-				askQuestion: async () => "ok",
-			},
-		});
-
-		expect(tools.map((tool) => tool.name)).toEqual([
-			"read_files",
-			"search_codebase",
-			"run_commands",
-			"fetch_web_content",
-			"editor",
-			"skills",
-		]);
-	});
-});
-
-describe("tool policy presets", () => {
-	it("returns empty policies for default", () => {
-		expect(createToolPoliciesWithPreset("default")).toEqual({});
-	});
-
-	it("yolo preset enables and auto-approves all tools", () => {
-		const policies = createToolPoliciesWithPreset("yolo");
-		expect(policies["*"]).toEqual({
-			enabled: true,
-			autoApprove: true,
-		});
-		expect(policies.ask_question).toEqual({
-			enabled: true,
-			autoApprove: true,
-		});
-		expect(policies.skills).toEqual({
-			enabled: true,
-			autoApprove: true,
-		});
-	});
-});