ctb 1.0.0 → 1.2.1

package/src/__tests__/cli.test.ts

@@ -0,0 +1,377 @@
+/**
+ * Unit tests for CLI argument parsing and env loading.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmdirSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+// Helper to create a test directory with .env file
+function createTestDir(): string {
+	const testDir = `/tmp/ctb-test-${Date.now()}`;
+	mkdirSync(testDir, { recursive: true });
+	return testDir;
+}
+
+function cleanupTestDir(dir: string): void {
+	try {
+		const envPath = join(dir, ".env");
+		if (existsSync(envPath)) unlinkSync(envPath);
+		rmdirSync(dir);
+	} catch {
+		// Ignore cleanup errors
+	}
+}
+
+describe("CLI .env file parsing", () => {
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = createTestDir();
+	});
+
+	afterEach(() => {
+		cleanupTestDir(testDir);
+	});
+
+	test("parses simple key=value pairs", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`TELEGRAM_BOT_TOKEN=test-token
+TELEGRAM_ALLOWED_USERS=123,456`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(env.TELEGRAM_BOT_TOKEN).toBe("test-token");
+		expect(env.TELEGRAM_ALLOWED_USERS).toBe("123,456");
+	});
+
+	test("handles quoted values", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`SINGLE='single quoted'
+DOUBLE="double quoted"`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			let value = trimmed.slice(eqIndex + 1).trim();
+			if (
+				(value.startsWith('"') && value.endsWith('"')) ||
+				(value.startsWith("'") && value.endsWith("'"))
+			) {
+				value = value.slice(1, -1);
+			}
+			env[trimmed.slice(0, eqIndex).trim()] = value;
+		}
+
+		expect(env.SINGLE).toBe("single quoted");
+		expect(env.DOUBLE).toBe("double quoted");
+	});
+
+	test("ignores comments", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`# This is a comment
+TELEGRAM_BOT_TOKEN=token
+# Another comment
+TELEGRAM_ALLOWED_USERS=123`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(Object.keys(env)).toHaveLength(2);
+		expect(env.TELEGRAM_BOT_TOKEN).toBe("token");
+	});
+
+	test("handles empty lines", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`TELEGRAM_BOT_TOKEN=token
+
+TELEGRAM_ALLOWED_USERS=123
+
+`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(Object.keys(env)).toHaveLength(2);
+	});
+
+	test("handles values with equals signs", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(envPath, `API_KEY=key=with=equals`);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(env.API_KEY).toBe("key=with=equals");
+	});
+
+	test("handles missing .env file gracefully", () => {
+		const nonExistentPath = join(testDir, "nonexistent", ".env");
+		expect(existsSync(nonExistentPath)).toBe(false);
+	});
+});
+
+describe("CLI argument parsing", () => {
+	function parseArgs(args: string[]): {
+		token?: string;
+		users?: string;
+		dir?: string;
+		help?: boolean;
+		version?: boolean;
+		tut?: boolean;
+	} {
+		const options: {
+			token?: string;
+			users?: string;
+			dir?: string;
+			help?: boolean;
+			version?: boolean;
+			tut?: boolean;
+		} = {};
+
+		for (const arg of args) {
+			if (arg === "--help" || arg === "-h") {
+				options.help = true;
+			} else if (arg === "--version" || arg === "-v") {
+				options.version = true;
+			} else if (arg === "tut" || arg === "tutorial") {
+				options.tut = true;
+			} else if (arg.startsWith("--token=")) {
+				options.token = arg.slice(8);
+			} else if (arg.startsWith("--users=")) {
+				options.users = arg.slice(8);
+			} else if (arg.startsWith("--dir=")) {
+				options.dir = arg.slice(6);
+			}
+		}
+
+		return options;
+	}
+
+	test("parses --help flag", () => {
+		expect(parseArgs(["--help"])).toEqual({ help: true });
+	});
+
+	test("parses -h shorthand", () => {
+		expect(parseArgs(["-h"])).toEqual({ help: true });
+	});
+
+	test("parses --version flag", () => {
+		expect(parseArgs(["--version"])).toEqual({ version: true });
+	});
+
+	test("parses -v shorthand", () => {
+		expect(parseArgs(["-v"])).toEqual({ version: true });
+	});
+
+	test("parses tut command", () => {
+		expect(parseArgs(["tut"])).toEqual({ tut: true });
+	});
+
+	test("parses tutorial command", () => {
+		expect(parseArgs(["tutorial"])).toEqual({ tut: true });
+	});
+
+	test("parses --token option", () => {
+		const result = parseArgs(["--token=my-bot-token"]);
+		expect(result.token).toBe("my-bot-token");
+	});
+
+	test("parses --users option", () => {
+		const result = parseArgs(["--users=123,456,789"]);
+		expect(result.users).toBe("123,456,789");
+	});
+
+	test("parses --dir option", () => {
+		const result = parseArgs(["--dir=/path/to/project"]);
+		expect(result.dir).toBe("/path/to/project");
+	});
+
+	test("parses multiple options", () => {
+		const result = parseArgs([
+			"--token=token123",
+			"--users=111,222",
+			"--dir=/home/user/project",
+		]);
+		expect(result.token).toBe("token123");
+		expect(result.users).toBe("111,222");
+		expect(result.dir).toBe("/home/user/project");
+	});
+
+	test("handles empty args array", () => {
+		expect(parseArgs([])).toEqual({});
+	});
+
+	test("ignores unknown flags", () => {
+		const result = parseArgs(["--unknown", "--another=value"]);
+		expect(result).toEqual({});
+	});
+
+	test("handles token with special characters", () => {
+		const result = parseArgs(["--token=123:ABC-xyz_789"]);
+		expect(result.token).toBe("123:ABC-xyz_789");
+	});
+
+	test("handles path with spaces when quoted", () => {
+		// This tests the arg as it would come from shell
+		const result = parseArgs(["--dir=/path/with spaces/project"]);
+		expect(result.dir).toBe("/path/with spaces/project");
+	});
+});
+
+describe("Path resolution with base directory", () => {
+	function resolvePath(path: string, baseDir?: string): string {
+		const homedir = () => "/Users/test";
+		const expanded = path.replace(/^~/, homedir());
+		if (baseDir && !expanded.startsWith("/")) {
+			// Simulate resolve(baseDir, expanded)
+			return `${baseDir}/${expanded}`.replace(/\/+/g, "/");
+		}
+		return expanded.startsWith("/") ? expanded : `/${expanded}`;
+	}
+
+	test("resolves absolute path unchanged", () => {
+		const result = resolvePath("/absolute/path", "/base/dir");
+		expect(result).toBe("/absolute/path");
+	});
+
+	test("resolves relative path from base directory", () => {
+		const result = resolvePath("relative/path", "/base/dir");
+		expect(result).toBe("/base/dir/relative/path");
+	});
+
+	test("expands tilde to home directory", () => {
+		const result = resolvePath("~/projects", "/base/dir");
+		expect(result).toBe("/Users/test/projects");
+	});
+
+	test("tilde path is not affected by base directory", () => {
+		const result = resolvePath("~/projects", "/base/dir");
+		expect(result).toBe("/Users/test/projects");
+	});
+
+	test("handles dot-relative paths", () => {
+		const result = resolvePath("./subdir", "/base/dir");
+		expect(result).toBe("/base/dir/./subdir");
+	});
+
+	test("handles parent directory paths", () => {
+		const result = resolvePath("../sibling", "/base/dir");
+		expect(result).toBe("/base/dir/../sibling");
+	});
+
+	test("works without base directory for absolute paths", () => {
+		const result = resolvePath("/absolute/path");
+		expect(result).toBe("/absolute/path");
+	});
+});
+
+describe("Instance directory hashing", () => {
+	function hashDir(dir: string): string {
+		let hash = 0;
+		for (let i = 0; i < dir.length; i++) {
+			const char = dir.charCodeAt(i);
+			hash = ((hash << 5) - hash + char) | 0;
+		}
+		return Math.abs(hash).toString(36).slice(0, 8);
+	}
+
+	test("generates consistent hash for same path", () => {
+		const path = "/Users/test/project";
+		expect(hashDir(path)).toBe(hashDir(path));
+	});
+
+	test("generates different hash for different paths", () => {
+		const hash1 = hashDir("/Users/test/project1");
+		const hash2 = hashDir("/Users/test/project2");
+		expect(hash1).not.toBe(hash2);
+	});
+
+	test("generates short hash (max 8 chars)", () => {
+		const hash = hashDir("/very/long/path/to/some/project/directory");
+		expect(hash.length).toBeLessThanOrEqual(8);
+	});
+
+	test("generates alphanumeric hash", () => {
+		const hash = hashDir("/Users/test/project");
+		expect(hash).toMatch(/^[a-z0-9]+$/);
+	});
+
+	test("handles empty string", () => {
+		const hash = hashDir("");
+		expect(hash).toBe("0");
+	});
+
+	test("handles root path", () => {
+		const hash = hashDir("/");
+		expect(hash.length).toBeGreaterThan(0);
+	});
+
+	test("handles home directory variations", () => {
+		const hash1 = hashDir("/Users/user1/project");
+		const hash2 = hashDir("/Users/user2/project");
+		expect(hash1).not.toBe(hash2);
+	});
+});

package/src/__tests__/file-detection.test.ts

@@ -0,0 +1,311 @@
+/**
+ * Unit tests for file path detection in formatting module.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { detectFilePaths } from "../formatting";
+
+describe("detectFilePaths", () => {
+	describe("paths in backticks", () => {
+		test("detects single file path in backticks", () => {
+			const text = "Here is the file: `/Users/test/file.txt`";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/Users/test/file.txt");
+			expect(result[0]?.display).toBe("test/file.txt");
+		});
+
+		test("detects multiple file paths in backticks", () => {
+			const text = "Files: `/home/user/a.txt` and `/home/user/b.json`";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(2);
+			expect(result[0]?.path).toBe("/home/user/a.txt");
+			expect(result[1]?.path).toBe("/home/user/b.json");
+		});
+
+		test("handles paths with special characters", () => {
+			const text = "`/Users/test/my-file_v2.txt`";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/Users/test/my-file_v2.txt");
+		});
+
+		test("handles paths with numbers", () => {
+			const text = "`/tmp/output123.csv`";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/tmp/output123.csv");
+		});
+	});
+
+	describe("paths after common prefixes", () => {
+		test("detects path after 'file:'", () => {
+			const text = "file: /Users/test/document.pdf";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/Users/test/document.pdf");
+		});
+
+		test("detects path after 'saved:'", () => {
+			const text = "saved: /home/user/output.json";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/home/user/output.json");
+		});
+
+		test("detects path after 'created:'", () => {
+			const text = "created: /tmp/new-file.txt";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/tmp/new-file.txt");
+		});
+
+		test("detects path after 'wrote:'", () => {
+			const text = "wrote: /var/log/app.log";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/var/log/app.log");
+		});
+
+		test("detects path after 'output:'", () => {
+			const text = "output: /home/user/result.csv";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/home/user/result.csv");
+		});
+
+		test("detects path after 'generated:'", () => {
+			const text = "generated: /tmp/report.html";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/tmp/report.html");
+		});
+
+		test("is case insensitive for prefixes", () => {
+			const text = "FILE: /Users/test/doc.txt";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+		});
+	});
+
+	describe("standalone absolute paths", () => {
+		test("detects /Users path", () => {
+			const text = "The file is at /Users/htlin/projects/code.ts";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/Users/htlin/projects/code.ts");
+		});
+
+		test("detects /home path", () => {
+			const text = "Located at /home/user/data.json";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/home/user/data.json");
+		});
+
+		test("detects /tmp path", () => {
+			const text = "Temp file: /tmp/cache.db";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/tmp/cache.db");
+		});
+
+		test("detects /var path", () => {
+			const text = "Log at /var/log/system.log";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/var/log/system.log");
+		});
+
+		test("detects /etc path", () => {
+			const text = "Config: /etc/nginx/nginx.conf";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/etc/nginx/nginx.conf");
+		});
+
+		test("detects /opt path", () => {
+			const text = "Binary at /opt/app/bin/run.sh";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/opt/app/bin/run.sh");
+		});
+	});
+
+	describe("deduplication", () => {
+		test("removes duplicate paths", () => {
+			const text =
+				"File `/Users/test/file.txt` was created at /Users/test/file.txt";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(1);
+		});
+
+		test("keeps unique paths", () => {
+			const text = "`/tmp/a.txt` `/tmp/b.txt` `/tmp/c.txt`";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(3);
+		});
+	});
+
+	describe("display name generation", () => {
+		test("uses last 2 path components for display", () => {
+			const text = "`/very/long/path/to/file.txt`";
+			const result = detectFilePaths(text);
+			expect(result[0]?.display).toBe("to/file.txt");
+		});
+
+		test("handles single component paths", () => {
+			const text = "`/tmp/file.txt`";
+			const result = detectFilePaths(text);
+			expect(result[0]?.display).toBe("tmp/file.txt");
+		});
+
+		test("handles root level files", () => {
+			const text = "file: /tmp/x.log";
+			const result = detectFilePaths(text);
+			expect(result[0]?.display).toBe("tmp/x.log");
+		});
+	});
+
+	describe("edge cases", () => {
+		test("returns empty array for text without paths", () => {
+			const text = "This is just regular text without any file paths.";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(0);
+		});
+
+		test("ignores relative paths", () => {
+			const text = "Use ./local/file.txt or ../parent/file.txt";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(0);
+		});
+
+		test("ignores URLs", () => {
+			const text = "Visit https://example.com/path/file.txt";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(0);
+		});
+
+		test("ignores paths without extensions", () => {
+			const text = "`/Users/test/directory`";
+			const result = detectFilePaths(text);
+			expect(result).toHaveLength(0);
+		});
+
+		test("handles empty string", () => {
+			const result = detectFilePaths("");
+			expect(result).toHaveLength(0);
+		});
+
+		test("handles paths with various extensions", () => {
+			const extensions = [
+				".txt",
+				".json",
+				".ts",
+				".js",
+				".py",
+				".md",
+				".yaml",
+				".yml",
+				".csv",
+				".html",
+				".css",
+				".xml",
+				".pdf",
+				".log",
+				".sh",
+			];
+			for (const ext of extensions) {
+				const text = `/tmp/file${ext}`;
+				const result = detectFilePaths(text);
+				expect(result.length).toBeGreaterThanOrEqual(0); // May or may not match depending on pattern
+			}
+		});
+
+		test("handles multiline text", () => {
+			const text = `
+First file: /Users/test/a.txt
+Second file: /Users/test/b.json
+Third: \`/tmp/c.csv\`
+`;
+			const result = detectFilePaths(text);
+			expect(result.length).toBeGreaterThanOrEqual(1);
+		});
+	});
+
+	describe("relative paths with working directory", () => {
+		test("resolves relative path with working directory", () => {
+			const text = "Created file: `output.txt`";
+			const result = detectFilePaths(text, "/Users/test/project");
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/Users/test/project/output.txt");
+		});
+
+		test("resolves nested relative path", () => {
+			const text = "See `src/main.ts`";
+			const result = detectFilePaths(text, "/Users/test/project");
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/Users/test/project/src/main.ts");
+		});
+
+		test("keeps absolute path unchanged with working directory", () => {
+			const text = "`/absolute/path/file.txt`";
+			const result = detectFilePaths(text, "/Users/test/project");
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/absolute/path/file.txt");
+		});
+
+		test("handles multiple relative paths", () => {
+			const text = "Files: `a.txt` and `b.json`";
+			const result = detectFilePaths(text, "/project");
+			expect(result).toHaveLength(2);
+			expect(result[0]?.path).toBe("/project/a.txt");
+			expect(result[1]?.path).toBe("/project/b.json");
+		});
+
+		test("handles relative path after prefix", () => {
+			const text = "output: result.csv";
+			const result = detectFilePaths(text, "/data");
+			expect(result).toHaveLength(1);
+			expect(result[0]?.path).toBe("/data/result.csv");
+		});
+
+		test("ignores relative paths without working directory", () => {
+			const text = "`relative/path.txt`";
+			const result = detectFilePaths(text);
+			// Without working directory, relative paths should still be captured but not resolved
+			expect(result.length).toBeGreaterThanOrEqual(0);
+		});
+	});
+
+	describe("complex scenarios", () => {
+		test("handles Claude-style response with file mentions", () => {
+			const text = `
+I've created the following files:
+
+1. Main script: \`/Users/htlin/project/src/main.ts\`
+2. Configuration: saved: /Users/htlin/project/config.json
+3. Test file at /Users/htlin/project/test/main.test.ts
+
+The output was written to \`/tmp/build-output.log\`.
+`;
+			const result = detectFilePaths(text);
+			expect(result.length).toBeGreaterThanOrEqual(3);
+			expect(result.some((r) => r.path.includes("main.ts"))).toBe(true);
+			expect(result.some((r) => r.path.includes("config.json"))).toBe(true);
+		});
+
+		test("handles paths in code blocks", () => {
+			const text = `
+Here's the code:
+\`\`\`
+const file = "/Users/test/data.json";
+\`\`\`
+Output saved to \`/tmp/result.txt\`
+`;
+			const result = detectFilePaths(text);
+			// Should find at least the backtick one
+			expect(result.some((r) => r.path.includes("result.txt"))).toBe(true);
+		});
+	});
+});