ctb 1.0.0 → 1.1.0

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);
+		});
+	});
+});

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);
+			}
+		}
+	});
+});

package/src/bookmarks.ts

@@ -99,8 +99,12 @@ export function isBookmarked(path: string): boolean {
 
 /**
  * Resolve path with ~ expansion.
+ * If baseDir is provided, relative paths are resolved from there.
  */
-export function resolvePath(path: string): string {
+export function resolvePath(path: string, baseDir?: string): string {
 	const expanded = path.replace(/^~/, homedir());
+	if (baseDir && !expanded.startsWith("/")) {
+		return resolve(baseDir, expanded);
+	}
 	return resolve(expanded);
 }

package/src/bot.ts

@@ -21,6 +21,7 @@ import {
 	handleDocument,
 	handleNew,
 	handlePhoto,
+	handlePreview,
 	handleRestart,
 	handleResume,
 	handleRetry,
@@ -65,6 +66,7 @@ bot.command("resume", handleResume);
 bot.command("restart", handleRestart);
 bot.command("retry", handleRetry);
 bot.command("cd", handleCd);
+bot.command("preview", handlePreview);
 bot.command("bookmarks", handleBookmarks);
 
 // ============== Message Handlers ==============
@@ -104,6 +106,21 @@ console.log("Starting bot...");
 const botInfo = await bot.api.getMe();
 console.log(`Bot started: @${botInfo.username}`);
 
+// Set up Telegram menu commands
+await bot.api.setMyCommands([
+	{ command: "start", description: "Show status and user ID" },
+	{ command: "new", description: "Start a fresh session" },
+	{ command: "resume", description: "Resume last session" },
+	{ command: "stop", description: "Interrupt current query" },
+	{ command: "status", description: "Check what Claude is doing" },
+	{ command: "cd", description: "Change working directory" },
+	{ command: "preview", description: "Download a file" },
+	{ command: "bookmarks", description: "Manage directory bookmarks" },
+	{ command: "retry", description: "Retry last message" },
+	{ command: "restart", description: "Restart the bot" },
+]);
+console.log("Menu commands registered");
+
 // Check for pending restart message to update
 if (existsSync(RESTART_FILE)) {
 	try {