@oomfware/cgr 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -2,53 +2,88 @@
 import { argument, choice, command, constant, message, object, option, or, string } from "@optique/core";
 import { run } from "@optique/run";
 import { spawn } from "node:child_process";
-import { dirname, join } from "node:path";
-import { optional, withDefault } from "@optique/core/modifiers";
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { mkdir, rm } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { multiple, optional, withDefault } from "@optique/core/modifiers";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, rm, stat, symlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { createInterface } from "node:readline";
+import checkbox from "@inquirer/checkbox";
+import confirm from "@inquirer/confirm";
 
+//#region src/lib/debug.ts
+const debugEnabled = process.env.DEBUG === "1" || process.env.CGR_DEBUG === "1";
+/**
+* logs a debug message to stderr if DEBUG=1 or CGR_DEBUG=1.
+* @param message the message to log
+*/
+const debug = (message$1) => {
+	if (debugEnabled) console.error(`[debug] ${message$1}`);
+};
+
+//#endregion
 //#region src/lib/git.ts
 /**
-* executes a git command and returns the result.
+* executes a git command silently, only showing output on failure.
+* when debug is enabled, inherits stdio to show git progress.
 * @param args git command arguments
 * @param cwd working directory
 * @returns promise that resolves when the command completes
 */
 const git = (args, cwd) => new Promise((resolve, reject) => {
+	debug(`git ${args.join(" ")}${cwd ? ` (in ${cwd})` : ""}`);
 	const proc = spawn("git", args, {
 		cwd,
-		stdio: "inherit"
+		stdio: debugEnabled ? "inherit" : [
+			"inherit",
+			"pipe",
+			"pipe"
+		]
+	});
+	let stderr = "";
+	if (!debugEnabled) proc.stderr.on("data", (data) => {
+		stderr += data.toString();
 	});
 	proc.on("close", (code) => {
 		if (code === 0) resolve();
-		else reject(/* @__PURE__ */ new Error(`git ${args[0]} failed with code ${code}`));
+		else {
+			if (stderr) process.stderr.write(stderr);
+			reject(/* @__PURE__ */ new Error(`git ${args[0]} failed with code ${code}`));
+		}
 	});
 	proc.on("error", reject);
 });
 /**
-* executes a git command and captures stdout.
+* executes a git command and captures stdout, only showing stderr on failure.
+* when debug is enabled, inherits stderr to show git progress.
 * @param args git command arguments
 * @param cwd working directory
 * @returns promise that resolves with stdout
 */
 const gitOutput = (args, cwd) => new Promise((resolve, reject) => {
+	debug(`git ${args.join(" ")}${cwd ? ` (in ${cwd})` : ""}`);
 	const proc = spawn("git", args, {
 		cwd,
 		stdio: [
 			"inherit",
 			"pipe",
-			"inherit"
+			debugEnabled ? "inherit" : "pipe"
 		]
 	});
 	let output = "";
+	let stderr = "";
 	proc.stdout.on("data", (data) => {
 		output += data.toString();
 	});
+	if (!debugEnabled) proc.stderr.on("data", (data) => {
+		stderr += data.toString();
+	});
 	proc.on("close", (code) => {
 		if (code === 0) resolve(output.trim());
-		else reject(/* @__PURE__ */ new Error(`git ${args[0]} failed with code ${code}`));
+		else {
+			if (stderr) process.stderr.write(stderr);
+			reject(/* @__PURE__ */ new Error(`git ${args[0]} failed with code ${code}`));
+		}
 	});
 	proc.on("error", reject);
 });
@@ -124,34 +159,52 @@ const getCacheDir = () => {
 * @returns the repos directory path
 */
 const getReposDir = () => join(getCacheDir(), "repos");
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
+const UNSAFE_CHARS = /[<>:"|?*\\]/g;
 /**
-* parses a git remote URL and extracts host, owner, and repo.
+* sanitizes a path segment to be safe on all filesystems.
+* encodes unsafe characters using percent-encoding and handles windows reserved names.
+* @param segment the path segment to sanitize
+* @returns sanitized segment
+*/
+const sanitizeSegment = (segment) => {
+	let safe = segment.replace(/%/g, "%25").replace(UNSAFE_CHARS, (c) => `%${c.charCodeAt(0).toString(16).padStart(2, "0")}`).replace(/[. ]+$/, (m) => m.split("").map((c) => `%${c.charCodeAt(0).toString(16).padStart(2, "0")}`).join(""));
+	if (WINDOWS_RESERVED.test(safe)) safe = `${safe}_`;
+	return safe;
+};
+/**
+* parses a git remote URL and extracts host and path.
 * supports HTTP(S), SSH, and bare URLs (assumes HTTPS).
 * @param remote the remote URL to parse
 * @returns parsed components or null if invalid
 */
 const parseRemote = (remote) => {
-	const httpMatch = remote.match(/^https?:\/\/([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	const httpMatch = remote.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
 	if (httpMatch) return {
 		host: httpMatch[1],
-		owner: httpMatch[2],
-		repo: httpMatch[3]
+		path: httpMatch[2]
 	};
-	const sshMatch = remote.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/);
+	const sshMatch = remote.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
 	if (sshMatch) return {
 		host: sshMatch[1],
-		owner: sshMatch[2],
-		repo: sshMatch[3]
+		path: sshMatch[2]
 	};
-	const bareMatch = remote.match(/^([^/]+)\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	const bareMatch = remote.match(/^([^/]+)\/(.+?)(?:\.git)?$/);
 	if (bareMatch) return {
 		host: bareMatch[1],
-		owner: bareMatch[2],
-		repo: bareMatch[3]
+		path: bareMatch[2]
 	};
 	return null;
 };
 /**
+* sanitizes a parsed remote path for safe filesystem storage.
+* @param parsed the parsed remote (host + path)
+* @returns sanitized path segments joined with the system separator
+*/
+const sanitizeRemotePath = (parsed) => {
+	return join(sanitizeSegment(parsed.host.toLowerCase()), ...parsed.path.toLowerCase().split("/").map(sanitizeSegment));
+};
+/**
 * normalizes a remote URL by prepending https:// if no protocol is present.
 * @param remote the remote URL to normalize
 * @returns normalized URL with protocol
@@ -168,7 +221,72 @@ const normalizeRemote = (remote) => {
 const getRepoCachePath = (remote) => {
 	const parsed = parseRemote(remote);
 	if (!parsed) return null;
-	return join(getReposDir(), parsed.host, parsed.owner, parsed.repo);
+	return join(getReposDir(), sanitizeRemotePath(parsed));
+};
+/**
+* parses `remote#branch` syntax.
+* @param input the input string, e.g. `github.com/owner/repo#develop`
+* @returns object with remote and optional branch
+*/
+const parseRemoteWithBranch = (input) => {
+	const hashIndex = input.lastIndexOf("#");
+	if (hashIndex === -1) return { remote: input };
+	return {
+		remote: input.slice(0, hashIndex),
+		branch: input.slice(hashIndex + 1)
+	};
+};
+/**
+* returns the sessions directory within the cache.
+* @returns the sessions directory path
+*/
+const getSessionsDir = () => join(getCacheDir(), "sessions");
+/**
+* creates a new session directory with a random UUID.
+* @returns the path to the created session directory
+*/
+const createSessionDir = async () => {
+	const sessionPath = join(getSessionsDir(), randomUUID());
+	await mkdir(sessionPath, { recursive: true });
+	return sessionPath;
+};
+/**
+* removes a session directory.
+* @param sessionPath the session directory path
+*/
+const cleanupSessionDir = async (sessionPath) => {
+	await rm(sessionPath, {
+		recursive: true,
+		force: true
+	});
+};
+
+//#endregion
+//#region src/lib/symlink.ts
+/**
+* builds symlinks in a session directory for all repositories.
+* handles name conflicts by appending `-2`, `-3`, etc.
+* @param sessionPath the session directory path
+* @param repos array of repository entries to symlink
+* @returns map of directory name -> repo entry
+*/
+const buildSymlinkDir = async (sessionPath, repos) => {
+	const result$1 = /* @__PURE__ */ new Map();
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const repo of repos) {
+		const repoName = basename(repo.parsed.path);
+		let name = repoName;
+		let suffix = 1;
+		while (usedNames.has(name)) {
+			suffix++;
+			name = `${repoName}-${suffix}`;
+		}
+		usedNames.add(name);
+		result$1.set(name, repo);
+		const linkPath = join(sessionPath, name);
+		await symlink(repo.cachePath, linkPath);
+	}
+	return result$1;
 };
 
 //#endregion
@@ -183,40 +301,76 @@ const schema$1 = object({
 		"sonnet",
 		"haiku"
 	]), { description: message`model to use for analysis` }), "haiku"),
-	branch: optional(option("-b", "--branch", string(), { description: message`branch to checkout` })),
-	remote: argument(string({ metavar: "REPO" }), { description: message`git remote URL (HTTP/HTTPS/SSH)` }),
+	branch: optional(option("-b", "--branch", string(), { description: message`branch to checkout (deprecated: use repo#branch instead)` })),
+	with: withDefault(multiple(option("-w", "--with", string(), { description: message`additional repository to include` })), []),
+	remote: argument(string({ metavar: "REPO" }), { description: message`git remote URL (HTTP/HTTPS/SSH), optionally with #branch` }),
 	question: argument(string({ metavar: "QUESTION" }), { description: message`question to ask about the repository` })
 });
 /**
-* handles the ask command.
-* clones/updates the repository and spawns Claude Code to answer the question.
-* @param args parsed command arguments
+* prints an error message for invalid remote URL and exits.
+* @param remote the invalid remote URL
 */
-const handler$1 = async (args) => {
-	const parsed = parseRemote(args.remote);
-	if (!parsed) {
-		console.error(`error: invalid remote URL: ${args.remote}`);
-		console.error("expected format: host/owner/repo, e.g.:");
-		console.error("  github.com/user/repo");
-		console.error("  https://github.com/user/repo");
-		console.error("  git@github.com:user/repo.git");
-		process.exit(1);
-	}
-	const cachePath = getRepoCachePath(args.remote);
+const exitInvalidRemote = (remote) => {
+	console.error(`error: invalid remote URL: ${remote}`);
+	console.error("expected format: host/path, e.g.:");
+	console.error("  github.com/user/repo");
+	console.error("  gitlab.com/group/subgroup/repo");
+	console.error("  https://github.com/user/repo");
+	console.error("  git@github.com:user/repo.git");
+	process.exit(1);
+};
+/**
+* validates and parses a remote string (with optional #branch).
+* @param input the remote string, possibly with #branch suffix
+* @returns parsed repo entry or exits on error
+*/
+const parseRepoInput = (input) => {
+	const { remote, branch } = parseRemoteWithBranch(input);
+	const parsed = parseRemote(remote);
+	if (!parsed) return exitInvalidRemote(remote);
+	const cachePath = getRepoCachePath(remote);
 	if (!cachePath) {
-		console.error(`error: could not determine cache path for: ${args.remote}`);
+		console.error(`error: could not determine cache path for: ${remote}`);
 		process.exit(1);
 	}
-	const remoteUrl = normalizeRemote(args.remote);
-	console.error(`preparing repository: ${parsed.host}/${parsed.owner}/${parsed.repo}`);
-	try {
-		await ensureRepo(remoteUrl, cachePath, args.branch);
-	} catch (err) {
-		console.error(`error: failed to prepare repository: ${err}`);
-		process.exit(1);
+	return {
+		remote,
+		parsed,
+		cachePath,
+		branch
+	};
+};
+/**
+* builds a context prompt for a single repository.
+* @param repo the repo entry
+* @returns context prompt string
+*/
+const buildSingleRepoContext = (repo) => {
+	return `You are examining ${`${repo.parsed.host}/${repo.parsed.path}`} (checked out on ${repo.branch ?? "default branch"}).`;
+};
+/**
+* builds a context prompt for multiple repositories.
+* @param dirMap map of directory name -> repo entry
+* @returns context prompt string
+*/
+const buildMultiRepoContext = (dirMap) => {
+	const lines = ["You are examining multiple repositories:", ""];
+	for (const [dirName, repo] of dirMap) {
+		const repoDisplay = `${repo.parsed.host}/${repo.parsed.path}`;
+		const branchDisplay = repo.branch ?? "default branch";
+		lines.push(`- ${dirName}/ -> ${repoDisplay} (checked out on ${branchDisplay})`);
 	}
-	const contextPrompt = `You are examining ${`${parsed.host}/${parsed.owner}/${parsed.repo}`} (checked out on ${args.branch ?? "default branch"}).`;
-	const claude = spawn("claude", [
+	return lines.join("\n");
+};
+/**
+* spawns Claude Code and waits for it to exit.
+* @param cwd working directory
+* @param contextPrompt context prompt for Claude
+* @param args command arguments
+* @returns promise that resolves with exit code
+*/
+const spawnClaude = (cwd, contextPrompt, args) => new Promise((resolve, reject) => {
+	const claudeArgs = [
 		"-p",
 		args.question,
 		"--model",
@@ -227,17 +381,71 @@ const handler$1 = async (args) => {
 		systemPromptPath,
 		"--append-system-prompt",
 		contextPrompt
-	], {
-		cwd: cachePath,
+	];
+	console.error("spawning claude...");
+	const claude = spawn("claude", claudeArgs, {
+		cwd,
 		stdio: "inherit"
 	});
 	claude.on("close", (code) => {
-		process.exit(code ?? 0);
+		resolve(code ?? 0);
 	});
 	claude.on("error", (err) => {
-		console.error(`error: failed to spawn claude: ${err}`);
-		process.exit(1);
+		reject(/* @__PURE__ */ new Error(`failed to spawn claude: ${err}`));
 	});
+});
+/**
+* handles the ask command.
+* clones/updates the repository and spawns Claude Code to answer the question.
+* @param args parsed command arguments
+*/
+const handler$1 = async (args) => {
+	const mainRepo = parseRepoInput(args.remote);
+	if (!mainRepo.branch && args.branch) mainRepo.branch = args.branch;
+	if (args.with.length === 0) {
+		const remoteUrl = normalizeRemote(mainRepo.remote);
+		console.error(`preparing repository: ${mainRepo.parsed.host}/${mainRepo.parsed.path}`);
+		try {
+			await ensureRepo(remoteUrl, mainRepo.cachePath, mainRepo.branch);
+		} catch (err) {
+			console.error(`error: failed to prepare repository: ${err}`);
+			process.exit(1);
+		}
+		const contextPrompt = buildSingleRepoContext(mainRepo);
+		const exitCode$1 = await spawnClaude(mainRepo.cachePath, contextPrompt, args);
+		process.exit(exitCode$1);
+	}
+	const allRepos = [mainRepo, ...args.with.map(parseRepoInput)];
+	console.error("preparing repositories...");
+	const prepareResults = await Promise.allSettled(allRepos.map(async (repo) => {
+		const remoteUrl = normalizeRemote(repo.remote);
+		const display = `${repo.parsed.host}/${repo.parsed.path}`;
+		console.error(`  preparing: ${display}`);
+		await ensureRepo(remoteUrl, repo.cachePath, repo.branch);
+		return repo;
+	}));
+	const failures = [];
+	for (let i = 0; i < prepareResults.length; i++) {
+		const result$1 = prepareResults[i];
+		if (result$1.status === "rejected") {
+			const repo = allRepos[i];
+			const display = `${repo.parsed.host}/${repo.parsed.path}`;
+			failures.push(`  ${display}: ${result$1.reason}`);
+		}
+	}
+	if (failures.length > 0) {
+		console.error("error: failed to prepare repositories:");
+		for (const failure of failures) console.error(failure);
+		process.exit(1);
+	}
+	const sessionPath = await createSessionDir();
+	let exitCode = 1;
+	try {
+		exitCode = await spawnClaude(sessionPath, buildMultiRepoContext(await buildSymlinkDir(sessionPath, allRepos)), args);
+	} finally {
+		await cleanupSessionDir(sessionPath);
+	}
+	process.exit(exitCode);
 };
 
 //#endregion
@@ -245,9 +453,23 @@ const handler$1 = async (args) => {
 const schema = object({
 	command: constant("clean"),
 	all: option("--all", { description: message`remove all cached repositories` }),
+	yes: option("-y", "--yes", { description: message`skip confirmation prompts` }),
 	remote: optional(argument(string({ metavar: "URL" }), { description: message`specific remote URL to clean` }))
 });
 /**
+* checks if a path exists.
+* @param path the path to check
+* @returns true if the path exists
+*/
+const exists = async (path) => {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
 * formats a byte size in human-readable form.
 * @param bytes size in bytes
 * @returns formatted string
@@ -263,82 +485,77 @@ const formatSize = (bytes) => {
 * @param dir directory path
 * @returns total size in bytes
 */
-const getDirSize = (dir) => {
+const getDirSize = async (dir) => {
 	let size = 0;
 	try {
-		const entries = readdirSync(dir, { withFileTypes: true });
+		const entries = await readdir(dir, { withFileTypes: true });
 		for (const entry of entries) {
 			const fullPath = join(dir, entry.name);
-			if (entry.isDirectory()) size += getDirSize(fullPath);
-			else size += statSync(fullPath).size;
+			if (entry.isDirectory()) size += await getDirSize(fullPath);
+			else {
+				const s = await stat(fullPath);
+				size += s.size;
+			}
 		}
 	} catch {}
 	return size;
 };
 /**
+* recursively finds git repositories within a directory.
+* yields directories that contain a .git subdirectory.
+* @param dir directory to search
+*/
+async function* findRepos(dir) {
+	try {
+		const entries = await readdir(dir, { withFileTypes: true });
+		if (entries.some((e) => e.name === ".git" && e.isDirectory())) yield dir;
+		else for (const entry of entries) if (entry.isDirectory()) yield* findRepos(join(dir, entry.name));
+	} catch {}
+}
+/**
 * lists all cached repositories with their sizes.
 * @returns array of { path, displayPath, size } objects
 */
-const listCachedRepos = () => {
+const listCachedRepos = async () => {
 	const reposDir = getReposDir();
+	if (!await exists(reposDir)) return [];
 	const repos = [];
-	if (!existsSync(reposDir)) return repos;
-	for (const host of readdirSync(reposDir)) {
-		const hostPath = join(reposDir, host);
-		if (!statSync(hostPath).isDirectory()) continue;
-		for (const owner of readdirSync(hostPath)) {
-			const ownerPath = join(hostPath, owner);
-			if (!statSync(ownerPath).isDirectory()) continue;
-			for (const repo of readdirSync(ownerPath)) {
-				const repoPath = join(ownerPath, repo);
-				if (!statSync(repoPath).isDirectory()) continue;
-				repos.push({
-					path: repoPath,
-					displayPath: `${host}/${owner}/${repo}`,
-					size: getDirSize(repoPath)
-				});
-			}
-		}
+	for await (const repoPath of findRepos(reposDir)) {
+		const displayPath = relative(reposDir, repoPath);
+		const size = await getDirSize(repoPath);
+		repos.push({
+			path: repoPath,
+			displayPath,
+			size
+		});
 	}
 	return repos;
 };
 /**
-* prompts the user for confirmation.
-* @param msg the prompt message
-* @returns promise that resolves to true if confirmed, or exits on interrupt
-*/
-const confirm = (msg) => new Promise((resolve) => {
-	let answered = false;
-	const rl = createInterface({
-		input: process.stdin,
-		output: process.stdout
-	});
-	rl.on("close", () => {
-		if (!answered) {
-			console.log();
-			process.exit(130);
-		}
-	});
-	rl.question(`${msg} [y/N] `, (answer) => {
-		answered = true;
-		rl.close();
-		resolve(answer.toLowerCase() === "y");
-	});
-});
-/**
 * handles the clean command.
 * @param args parsed command arguments
 */
 const handler = async (args) => {
 	const reposDir = getReposDir();
+	const sessionsDir = getSessionsDir();
 	if (args.all) {
-		if (!existsSync(reposDir)) {
-			console.log("no cached repositories found");
+		const reposExist = await exists(reposDir);
+		const sessionsExist$1 = await exists(sessionsDir);
+		if (!reposExist && !sessionsExist$1) {
+			console.log("no cached data found");
 			return;
 		}
-		const size = getDirSize(reposDir);
-		console.log(`removing all cached repositories (${formatSize(size)})`);
-		await rm(reposDir, { recursive: true });
+		let totalSize$1 = 0;
+		if (reposExist) totalSize$1 += await getDirSize(reposDir);
+		if (sessionsExist$1) totalSize$1 += await getDirSize(sessionsDir);
+		if (!args.yes) {
+			if (!await confirm({
+				message: `remove all cached data? (${formatSize(totalSize$1)})`,
+				default: false
+			})) return;
+		}
+		if (reposExist) await rm(reposDir, { recursive: true });
+		if (sessionsExist$1) await rm(sessionsDir, { recursive: true });
 		console.log("done");
 		return;
 	}
@@ -348,33 +565,51 @@ const handler = async (args) => {
 			console.error(`error: invalid remote URL: ${args.remote}`);
 			process.exit(1);
 		}
-		if (!existsSync(cachePath)) {
+		if (!await exists(cachePath)) {
 			console.error(`error: repository not cached: ${args.remote}`);
 			process.exit(1);
 		}
-		const size = getDirSize(cachePath);
-		console.log(`removing ${cachePath} (${formatSize(size)})`);
+		const size = await getDirSize(cachePath);
+		if (!args.yes) {
+			if (!await confirm({
+				message: `remove ${args.remote}? (${formatSize(size)})`,
+				default: false
+			})) return;
+		}
 		await rm(cachePath, { recursive: true });
 		console.log("done");
 		return;
 	}
-	const repos = listCachedRepos();
-	if (repos.length === 0) {
-		console.log("no cached repositories found");
+	const repos = await listCachedRepos();
+	const sessionsExist = await exists(sessionsDir);
+	const sessionsSize = sessionsExist ? await getDirSize(sessionsDir) : 0;
+	if (repos.length === 0 && !sessionsExist) {
+		console.log("no cached data found");
 		return;
 	}
-	console.log("cached repositories:\n");
+	const choices = repos.map((repo) => ({
+		name: `${repo.displayPath.padEnd(50)} ${formatSize(repo.size)}`,
+		value: repo.path
+	}));
+	if (sessionsExist && sessionsSize > 0) choices.push({
+		name: `${"(sessions)".padEnd(50)} ${formatSize(sessionsSize)}`,
+		value: sessionsDir
+	});
+	const selected = await checkbox({
+		message: "select items to remove",
+		choices
+	});
+	if (selected.length === 0) return;
 	let totalSize = 0;
-	for (const repo of repos) {
-		console.log(`  ${repo.displayPath.padEnd(50)} ${formatSize(repo.size)}`);
-		totalSize += repo.size;
-	}
-	console.log(`\n  total: ${formatSize(totalSize)}`);
-	console.log();
-	if (await confirm("remove all cached repositories?")) {
-		await rm(reposDir, { recursive: true });
-		console.log("done");
+	for (const path of selected) totalSize += await getDirSize(path);
+	if (!args.yes) {
+		if (!await confirm({
+			message: `remove ${selected.length} item(s)? (${formatSize(totalSize)})`,
+			default: false
+		})) return;
 	}
+	for (const path of selected) await rm(path, { recursive: true });
+	console.log("done");
 };
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oomfware/cgr",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "ask questions about git repositories using Claude Code",
   "license": "0BSD",
   "repository": {
@@ -21,6 +21,8 @@
     "access": "public"
   },
   "dependencies": {
+    "@inquirer/checkbox": "5.0.4",
+    "@inquirer/confirm": "6.0.4",
     "@optique/core": "^0.9.1",
     "@optique/run": "^0.9.1"
   },