ctb 1.0.0 → 1.2.1

package/src/__tests__/session.test.ts

@@ -0,0 +1,399 @@
+/**
+ * Unit tests for session module - model, cost, thinking, and plan mode features.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+import { ClaudeSession, getThinkingLevel } from "../session";
+
+describe("getThinkingLevel", () => {
+	// Default keywords from config.ts:
+	// THINKING_KEYWORDS: "think,pensa,ragiona"
+	// THINKING_DEEP_KEYWORDS: "ultrathink,think hard,pensa bene"
+
+	describe("deep thinking triggers", () => {
+		test("triggers on 'think hard'", () => {
+			expect(getThinkingLevel("Please think hard about this")).toBe(50000);
+		});
+
+		test("triggers on 'ultrathink'", () => {
+			expect(getThinkingLevel("ultrathink about the problem")).toBe(50000);
+		});
+
+		test("triggers on 'pensa bene' (Italian)", () => {
+			expect(getThinkingLevel("pensa bene prima di rispondere")).toBe(50000);
+		});
+
+		test("is case insensitive", () => {
+			expect(getThinkingLevel("THINK HARD about this")).toBe(50000);
+			expect(getThinkingLevel("ULTRATHINK")).toBe(50000);
+		});
+	});
+
+	describe("normal thinking triggers", () => {
+		test("triggers on 'think'", () => {
+			expect(getThinkingLevel("Let me think about this")).toBe(10000);
+		});
+
+		test("triggers on 'pensa' (Italian)", () => {
+			expect(getThinkingLevel("pensa a questo problema")).toBe(10000);
+		});
+
+		test("triggers on 'ragiona' (Italian)", () => {
+			expect(getThinkingLevel("ragiona sul codice")).toBe(10000);
+		});
+
+		test("is case insensitive", () => {
+			expect(getThinkingLevel("THINK about it")).toBe(10000);
+			expect(getThinkingLevel("PENSA attentamente")).toBe(10000);
+		});
+	});
+
+	describe("no thinking triggers", () => {
+		test("returns 0 for simple messages", () => {
+			expect(getThinkingLevel("Hello")).toBe(0);
+			expect(getThinkingLevel("What time is it?")).toBe(0);
+			expect(getThinkingLevel("Show me the file")).toBe(0);
+		});
+
+		test("returns 0 for empty string", () => {
+			expect(getThinkingLevel("")).toBe(0);
+		});
+
+		test("returns 0 for unrelated words", () => {
+			expect(getThinkingLevel("analyze this code")).toBe(0);
+			expect(getThinkingLevel("consider the options")).toBe(0);
+			expect(getThinkingLevel("evaluate this approach")).toBe(0);
+		});
+	});
+
+	describe("priority", () => {
+		test("deep triggers take precedence over normal", () => {
+			// "think hard" should trigger deep (50000), not normal "think" (10000)
+			expect(getThinkingLevel("think hard")).toBe(50000);
+		});
+	});
+});
+
+describe("ClaudeSession", () => {
+	let session: ClaudeSession;
+
+	beforeEach(() => {
+		session = new ClaudeSession();
+	});
+
+	describe("model selection", () => {
+		test("defaults to sonnet", () => {
+			expect(session.currentModel).toBe("sonnet");
+		});
+
+		test("can be set to opus", () => {
+			session.currentModel = "opus";
+			expect(session.currentModel).toBe("opus");
+		});
+
+		test("can be set to haiku", () => {
+			session.currentModel = "haiku";
+			expect(session.currentModel).toBe("haiku");
+		});
+
+		test("can switch between models", () => {
+			session.currentModel = "opus";
+			expect(session.currentModel).toBe("opus");
+
+			session.currentModel = "haiku";
+			expect(session.currentModel).toBe("haiku");
+
+			session.currentModel = "sonnet";
+			expect(session.currentModel).toBe("sonnet");
+		});
+	});
+
+	describe("forceThinking", () => {
+		test("defaults to null", () => {
+			expect(session.forceThinking).toBeNull();
+		});
+
+		test("can be set to specific token count", () => {
+			session.forceThinking = 10000;
+			expect(session.forceThinking).toBe(10000);
+		});
+
+		test("can be set to 0 (off)", () => {
+			session.forceThinking = 0;
+			expect(session.forceThinking).toBe(0);
+		});
+
+		test("can be set to deep (50000)", () => {
+			session.forceThinking = 50000;
+			expect(session.forceThinking).toBe(50000);
+		});
+	});
+
+	describe("planMode", () => {
+		test("defaults to false", () => {
+			expect(session.planMode).toBe(false);
+		});
+
+		test("can be toggled on", () => {
+			session.planMode = true;
+			expect(session.planMode).toBe(true);
+		});
+
+		test("can be toggled off", () => {
+			session.planMode = true;
+			session.planMode = false;
+			expect(session.planMode).toBe(false);
+		});
+	});
+
+	describe("token usage tracking", () => {
+		test("starts with zero totals", () => {
+			expect(session.totalInputTokens).toBe(0);
+			expect(session.totalOutputTokens).toBe(0);
+			expect(session.totalCacheReadTokens).toBe(0);
+		});
+
+		test("can accumulate input tokens", () => {
+			session.totalInputTokens += 1000;
+			session.totalInputTokens += 500;
+			expect(session.totalInputTokens).toBe(1500);
+		});
+
+		test("can accumulate output tokens", () => {
+			session.totalOutputTokens += 2000;
+			session.totalOutputTokens += 800;
+			expect(session.totalOutputTokens).toBe(2800);
+		});
+
+		test("can accumulate cache read tokens", () => {
+			session.totalCacheReadTokens += 500;
+			session.totalCacheReadTokens += 300;
+			expect(session.totalCacheReadTokens).toBe(800);
+		});
+	});
+
+	describe("estimateCost", () => {
+		describe("sonnet pricing", () => {
+			test("calculates zero cost for zero tokens", () => {
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(0);
+				expect(cost.outputCost).toBe(0);
+				expect(cost.total).toBe(0);
+			});
+
+			test("calculates cost for 1M input tokens", () => {
+				session.totalInputTokens = 1_000_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(3); // $3 per 1M input
+				expect(cost.outputCost).toBe(0);
+				expect(cost.total).toBe(3);
+			});
+
+			test("calculates cost for 1M output tokens", () => {
+				session.totalOutputTokens = 1_000_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(0);
+				expect(cost.outputCost).toBe(15); // $15 per 1M output
+				expect(cost.total).toBe(15);
+			});
+
+			test("calculates combined cost", () => {
+				session.totalInputTokens = 500_000;
+				session.totalOutputTokens = 100_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(1.5); // $3 * 0.5
+				expect(cost.outputCost).toBe(1.5); // $15 * 0.1
+				expect(cost.total).toBe(3);
+			});
+		});
+
+		describe("opus pricing", () => {
+			beforeEach(() => {
+				session.currentModel = "opus";
+			});
+
+			test("calculates cost for 1M input tokens", () => {
+				session.totalInputTokens = 1_000_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(15); // $15 per 1M input
+			});
+
+			test("calculates cost for 1M output tokens", () => {
+				session.totalOutputTokens = 1_000_000;
+				const cost = session.estimateCost();
+				expect(cost.outputCost).toBe(75); // $75 per 1M output
+			});
+
+			test("calculates combined cost", () => {
+				session.totalInputTokens = 100_000;
+				session.totalOutputTokens = 50_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(1.5); // $15 * 0.1
+				expect(cost.outputCost).toBe(3.75); // $75 * 0.05
+				expect(cost.total).toBe(5.25);
+			});
+		});
+
+		describe("haiku pricing", () => {
+			beforeEach(() => {
+				session.currentModel = "haiku";
+			});
+
+			test("calculates cost for 1M input tokens", () => {
+				session.totalInputTokens = 1_000_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(0.25); // $0.25 per 1M input
+			});
+
+			test("calculates cost for 1M output tokens", () => {
+				session.totalOutputTokens = 1_000_000;
+				const cost = session.estimateCost();
+				expect(cost.outputCost).toBe(1.25); // $1.25 per 1M output
+			});
+
+			test("calculates combined cost", () => {
+				session.totalInputTokens = 4_000_000;
+				session.totalOutputTokens = 800_000;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBe(1); // $0.25 * 4
+				expect(cost.outputCost).toBe(1); // $1.25 * 0.8
+				expect(cost.total).toBe(2);
+			});
+		});
+
+		describe("small token counts", () => {
+			test("calculates fractional costs", () => {
+				session.totalInputTokens = 1000;
+				session.totalOutputTokens = 500;
+				const cost = session.estimateCost();
+				expect(cost.inputCost).toBeCloseTo(0.003, 5); // $3 * 0.001
+				expect(cost.outputCost).toBeCloseTo(0.0075, 5); // $15 * 0.0005
+				expect(cost.total).toBeCloseTo(0.0105, 5);
+			});
+		});
+	});
+
+	describe("kill", () => {
+		test("resets sessionId", async () => {
+			session.sessionId = "test-session-123";
+			await session.kill();
+			expect(session.sessionId).toBeNull();
+		});
+
+		test("resets lastActivity", async () => {
+			session.lastActivity = new Date();
+			await session.kill();
+			expect(session.lastActivity).toBeNull();
+		});
+
+		test("resets token totals", async () => {
+			session.totalInputTokens = 10000;
+			session.totalOutputTokens = 5000;
+			session.totalCacheReadTokens = 2000;
+			await session.kill();
+			expect(session.totalInputTokens).toBe(0);
+			expect(session.totalOutputTokens).toBe(0);
+			expect(session.totalCacheReadTokens).toBe(0);
+		});
+
+		test("resets planMode", async () => {
+			session.planMode = true;
+			await session.kill();
+			expect(session.planMode).toBe(false);
+		});
+
+		test("resets forceThinking", async () => {
+			session.forceThinking = 50000;
+			await session.kill();
+			expect(session.forceThinking).toBeNull();
+		});
+
+		test("preserves currentModel", async () => {
+			session.currentModel = "opus";
+			await session.kill();
+			expect(session.currentModel).toBe("opus");
+		});
+	});
+
+	describe("isActive", () => {
+		test("returns false when no sessionId", () => {
+			expect(session.isActive).toBe(false);
+		});
+
+		test("returns true when sessionId exists", () => {
+			session.sessionId = "test-session-123";
+			expect(session.isActive).toBe(true);
+		});
+	});
+
+	describe("workingDir", () => {
+		test("can get working directory", () => {
+			expect(typeof session.workingDir).toBe("string");
+		});
+
+		test("setWorkingDir changes directory", () => {
+			const newDir = "/tmp/test-dir";
+			session.setWorkingDir(newDir);
+			expect(session.workingDir).toBe(newDir);
+		});
+
+		test("setWorkingDir clears sessionId", () => {
+			session.sessionId = "test-session-123";
+			session.setWorkingDir("/tmp/new-dir");
+			expect(session.sessionId).toBeNull();
+		});
+	});
+
+	describe("stop", () => {
+		test("returns false when nothing is running", async () => {
+			const result = await session.stop();
+			expect(result).toBe(false);
+		});
+	});
+
+	describe("interrupt flags", () => {
+		test("markInterrupt and consumeInterruptFlag work together", () => {
+			expect(session.consumeInterruptFlag()).toBe(false);
+			session.markInterrupt();
+			expect(session.consumeInterruptFlag()).toBe(true);
+			expect(session.consumeInterruptFlag()).toBe(false); // Consumed
+		});
+	});
+
+	describe("processing state", () => {
+		test("startProcessing returns cleanup function", () => {
+			expect(session.isRunning).toBe(false);
+			const cleanup = session.startProcessing();
+			expect(session.isRunning).toBe(true);
+			cleanup();
+			expect(session.isRunning).toBe(false);
+		});
+	});
+
+	describe("undo/checkpointing", () => {
+		test("canUndo is false by default", () => {
+			expect(session.canUndo).toBe(false);
+		});
+
+		test("undoCheckpoints is 0 by default", () => {
+			expect(session.undoCheckpoints).toBe(0);
+		});
+
+		test("undo fails when no session active", async () => {
+			const [success, message] = await session.undo();
+			expect(success).toBe(false);
+			expect(message).toContain("No active session");
+		});
+
+		test("kill resets checkpoints", async () => {
+			// Simulate having checkpoints (by accessing private property for testing)
+			// @ts-expect-error - accessing private for test
+			session._userMessageUuids = ["uuid1", "uuid2"];
+			expect(session.undoCheckpoints).toBe(2);
+
+			await session.kill();
+			expect(session.undoCheckpoints).toBe(0);
+			expect(session.canUndo).toBe(false);
+		});
+	});
+});

package/src/__tests__/shell-command.test.ts

@@ -0,0 +1,310 @@
+/**
+ * Unit tests for shell command execution (!command feature).
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { spawn } from "node:child_process";
+import { mkdirSync, rmdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Execute a shell command and return output.
+ * This is a copy of the function from text.ts for testing.
+ */
+async function execShellCommand(
+	command: string,
+	cwd: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	return new Promise((resolve) => {
+		const proc = spawn("bash", ["-c", command], {
+			cwd,
+			timeout: 30000,
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		proc.stdout.on("data", (data) => {
+			stdout += data.toString();
+		});
+
+		proc.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+
+		proc.on("close", (code) => {
+			resolve({ stdout, stderr, exitCode: code ?? 0 });
+		});
+
+		proc.on("error", (err) => {
+			resolve({ stdout, stderr: err.message, exitCode: 1 });
+		});
+	});
+}
+
+describe("Shell command execution", () => {
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = `/tmp/shell-test-${Date.now()}`;
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		try {
+			// Clean up test files
+			const files = ["test.txt", "output.txt", "script.sh"];
+			for (const file of files) {
+				try {
+					Bun.spawnSync(["rm", "-f", join(testDir, file)]);
+				} catch {
+					// Ignore
+				}
+			}
+			rmdirSync(testDir);
+		} catch {
+			// Ignore cleanup errors
+		}
+	});
+
+	describe("basic commands", () => {
+		test("executes echo command", async () => {
+			const result = await execShellCommand("echo hello", testDir);
+			expect(result.stdout.trim()).toBe("hello");
+			expect(result.exitCode).toBe(0);
+		});
+
+		test("executes pwd command", async () => {
+			const result = await execShellCommand("pwd", testDir);
+			// macOS resolves /tmp to /private/tmp
+			expect(result.stdout.trim()).toMatch(/\/?tmp\/shell-test-/);
+			expect(result.exitCode).toBe(0);
+		});
+
+		test("executes ls command", async () => {
+			// Create a test file
+			writeFileSync(join(testDir, "test.txt"), "content");
+			const result = await execShellCommand("ls", testDir);
+			expect(result.stdout).toContain("test.txt");
+			expect(result.exitCode).toBe(0);
+		});
+
+		test("executes mkdir command", async () => {
+			const result = await execShellCommand("mkdir -p subdir", testDir);
+			expect(result.exitCode).toBe(0);
+			// Clean up
+			Bun.spawnSync(["rmdir", join(testDir, "subdir")]);
+		});
+
+		test("executes cat command", async () => {
+			writeFileSync(join(testDir, "test.txt"), "file content");
+			const result = await execShellCommand("cat test.txt", testDir);
+			expect(result.stdout.trim()).toBe("file content");
+			expect(result.exitCode).toBe(0);
+		});
+	});
+
+	describe("command with arguments", () => {
+		test("handles multiple arguments", async () => {
+			const result = await execShellCommand("echo one two three", testDir);
+			expect(result.stdout.trim()).toBe("one two three");
+		});
+
+		test("handles quoted arguments", async () => {
+			const result = await execShellCommand('echo "hello world"', testDir);
+			expect(result.stdout.trim()).toBe("hello world");
+		});
+
+		test("handles special characters in arguments", async () => {
+			const result = await execShellCommand("echo 'test$var'", testDir);
+			expect(result.stdout.trim()).toBe("test$var");
+		});
+	});
+
+	describe("piped commands", () => {
+		test("handles simple pipe", async () => {
+			const result = await execShellCommand("echo hello | cat", testDir);
+			expect(result.stdout.trim()).toBe("hello");
+		});
+
+		test("handles grep pipe", async () => {
+			const result = await execShellCommand(
+				"echo -e 'line1\\nline2\\nline3' | grep line2",
+				testDir,
+			);
+			expect(result.stdout.trim()).toBe("line2");
+		});
+
+		test("handles wc pipe", async () => {
+			const result = await execShellCommand("echo hello | wc -c", testDir);
+			expect(Number.parseInt(result.stdout.trim())).toBeGreaterThan(0);
+		});
+	});
+
+	describe("error handling", () => {
+		test("returns non-zero exit code for failed command", async () => {
+			const result = await execShellCommand(
+				"ls /nonexistent-directory-12345",
+				testDir,
+			);
+			expect(result.exitCode).not.toBe(0);
+		});
+
+		test("captures stderr for errors", async () => {
+			const result = await execShellCommand(
+				"ls /nonexistent-directory-12345",
+				testDir,
+			);
+			expect(result.stderr.length).toBeGreaterThan(0);
+		});
+
+		test("handles command not found", async () => {
+			const result = await execShellCommand("nonexistent-command-xyz", testDir);
+			expect(result.exitCode).not.toBe(0);
+		});
+
+		test("handles syntax errors", async () => {
+			const result = await execShellCommand("echo 'unclosed", testDir);
+			expect(result.exitCode).not.toBe(0);
+		});
+	});
+
+	describe("working directory", () => {
+		test("executes in specified directory", async () => {
+			const result = await execShellCommand("pwd", testDir);
+			// macOS resolves /tmp to /private/tmp
+			expect(result.stdout.trim()).toMatch(/\/?tmp\/shell-test-/);
+		});
+
+		test("creates file in working directory", async () => {
+			await execShellCommand("touch newfile.txt", testDir);
+			const lsResult = await execShellCommand("ls newfile.txt", testDir);
+			expect(lsResult.exitCode).toBe(0);
+			// Clean up
+			Bun.spawnSync(["rm", join(testDir, "newfile.txt")]);
+		});
+
+		test("handles relative paths in working directory", async () => {
+			writeFileSync(join(testDir, "data.txt"), "content");
+			const result = await execShellCommand("cat ./data.txt", testDir);
+			expect(result.stdout.trim()).toBe("content");
+		});
+	});
+
+	describe("output handling", () => {
+		test("handles large stdout", async () => {
+			const result = await execShellCommand("seq 1 1000", testDir);
+			expect(result.stdout.split("\n").length).toBeGreaterThan(100);
+		});
+
+		test("handles multiline output", async () => {
+			const result = await execShellCommand(
+				"echo -e 'line1\\nline2\\nline3'",
+				testDir,
+			);
+			const lines = result.stdout.trim().split("\n");
+			expect(lines).toHaveLength(3);
+		});
+
+		test("handles mixed stdout and stderr", async () => {
+			const result = await execShellCommand("echo out; echo err >&2", testDir);
+			expect(result.stdout.trim()).toBe("out");
+			expect(result.stderr.trim()).toBe("err");
+		});
+
+		test("handles empty output", async () => {
+			const result = await execShellCommand("true", testDir);
+			expect(result.stdout).toBe("");
+			expect(result.exitCode).toBe(0);
+		});
+	});
+
+	describe("shell features", () => {
+		test("handles environment variables", async () => {
+			const result = await execShellCommand("echo $HOME", testDir);
+			expect(result.stdout.trim().length).toBeGreaterThan(0);
+		});
+
+		test("handles command substitution", async () => {
+			const result = await execShellCommand("echo $(pwd)", testDir);
+			// macOS resolves /tmp to /private/tmp
+			expect(result.stdout.trim()).toMatch(/\/?tmp\/shell-test-/);
+		});
+
+		test("handles glob patterns", async () => {
+			writeFileSync(join(testDir, "a.txt"), "");
+			writeFileSync(join(testDir, "b.txt"), "");
+			const result = await execShellCommand("ls *.txt", testDir);
+			expect(result.stdout).toContain("a.txt");
+			expect(result.stdout).toContain("b.txt");
+			// Clean up
+			Bun.spawnSync(["rm", join(testDir, "a.txt"), join(testDir, "b.txt")]);
+		});
+
+		test("handles redirections", async () => {
+			await execShellCommand("echo content > output.txt", testDir);
+			const result = await execShellCommand("cat output.txt", testDir);
+			expect(result.stdout.trim()).toBe("content");
+		});
+
+		test("handles && chaining", async () => {
+			const result = await execShellCommand(
+				"echo first && echo second",
+				testDir,
+			);
+			expect(result.stdout).toContain("first");
+			expect(result.stdout).toContain("second");
+		});
+
+		test("handles || chaining", async () => {
+			const result = await execShellCommand("false || echo fallback", testDir);
+			expect(result.stdout.trim()).toBe("fallback");
+		});
+	});
+});
+
+describe("Shell command prefix detection", () => {
+	test("detects ! prefix", () => {
+		const message = "!ls -la";
+		expect(message.startsWith("!")).toBe(true);
+		expect(message.slice(1).trim()).toBe("ls -la");
+	});
+
+	test("extracts command after prefix", () => {
+		const testCases = [
+			{ input: "!pwd", expected: "pwd" },
+			{ input: "! pwd", expected: "pwd" },
+			{ input: "!  pwd", expected: "pwd" },
+			{ input: "!ls -la /tmp", expected: "ls -la /tmp" },
+			{ input: "!echo hello world", expected: "echo hello world" },
+		];
+
+		for (const { input, expected } of testCases) {
+			expect(input.slice(1).trim()).toBe(expected);
+		}
+	});
+
+	test("handles empty command after prefix", () => {
+		const message = "!";
+		const command = message.slice(1).trim();
+		expect(command).toBe("");
+	});
+
+	test("handles whitespace only after prefix", () => {
+		const message = "!   ";
+		const command = message.slice(1).trim();
+		expect(command).toBe("");
+	});
+
+	test("does not confuse with exclamation in text", () => {
+		const notCommands = ["Hello! How are you?", "This is great!", "! at end"];
+
+		for (const text of notCommands) {
+			// These start with ! should still be detected
+			// But "Hello!" doesn't start with !
+			if (!text.startsWith("!")) {
+				expect(text.startsWith("!")).toBe(false);
+			}
+		}
+	});
+});