@oomfware/cgr 0.1.7 → 0.1.8

package/README.md

@@ -42,10 +42,16 @@ cgr clean --all
 ## commands
 
 ```
-cgr ask [-m opus|sonnet|haiku] [-w repo[#branch] ...] <repo>[#branch] <question>
+cgr ask [-m opus|sonnet|haiku] [-s] [-w repo[#branch] ...] <repo>[#branch] <question>
 cgr clean [--all | <repo>]
 ```
 
+| option          | description                                       |
+| --------------- | ------------------------------------------------- |
+| `-m, --model`   | model to use: opus, sonnet, haiku (default haiku) |
+| `-s, --shallow` | use shallow clone (depth 1) for faster cloning    |
+| `-w, --with`    | additional repository to include (repeatable)     |
+
 | command | description                                                       |
 | ------- | ----------------------------------------------------------------- |
 | `ask`   | clone/update a repository and ask Claude Code a question about it |
@@ -82,6 +88,7 @@ You can use `@oomfware/cgr` to ask questions about external repositories.
 
     options:
       -m, --model <model>   model to use: opus, sonnet, haiku (default: haiku)
+      -s, --shallow         use shallow clone (depth 1) for faster cloning
       -w, --with <repo>     additional repository to include, supports #branch (repeatable)
 
 Useful repositories:

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { argument, choice, command, constant, message, object, option, or, string } from "@optique/core";
+import { argument, choice, command, constant, flag, message, object, option, or, string } from "@optique/core";
 import { run } from "@optique/run";
 import { spawn } from "node:child_process";
 import { basename, dirname, join, relative } from "node:path";
@@ -102,14 +102,24 @@ const gitOutput = (args, cwd) => new Promise((resolve, reject) => {
 	proc.on("error", reject);
 });
 /**
+* checks if a repository is a shallow clone.
+* @param cachePath the local repository path
+* @returns true if the repository is shallow
+*/
+const isShallowRepo = async (cachePath) => {
+	return await gitOutput(["rev-parse", "--is-shallow-repository"], cachePath) === "true";
+};
+/**
 * clones a repository to the cache path.
 * @param remote the remote URL
 * @param cachePath the local cache path
 * @param branch optional branch to checkout
+* @param shallow if true, performs a shallow clone with depth 1
 */
-const cloneRepo = async (remote, cachePath, branch) => {
+const cloneRepo = async (remote, cachePath, branch, shallow) => {
 	await mkdir(dirname(cachePath), { recursive: true });
 	const args = ["clone"];
+	if (shallow) args.push("--depth", "1");
 	if (branch) args.push("--branch", branch);
 	args.push(remote, cachePath);
 	await git(args);
@@ -119,9 +129,23 @@ const cloneRepo = async (remote, cachePath, branch) => {
 * discards any local modifications, staged changes, and untracked files.
 * @param cachePath the local cache path
 * @param branch optional branch to checkout (uses default branch if not specified)
+* @param shallow if true, keeps shallow clone; if false, unshallows if needed
 */
-const updateRepo = async (cachePath, branch) => {
-	await git(["fetch", "origin"], cachePath);
+const updateRepo = async (cachePath, branch, shallow) => {
+	const currentlyShallow = await isShallowRepo(cachePath);
+	if (!shallow && currentlyShallow) await git([
+		"fetch",
+		"--unshallow",
+		"origin"
+	], cachePath);
+	else if (shallow && !currentlyShallow) console.error("  note: repository is already a full clone, use `cgr clean` to re-clone as shallow");
+	if (shallow && currentlyShallow) await git([
+		"fetch",
+		"--depth",
+		"1",
+		"origin"
+	], cachePath);
+	else if (!currentlyShallow || !shallow) await git(["fetch", "origin"], cachePath);
 	let targetBranch = branch;
 	if (!targetBranch) targetBranch = (await gitOutput(["symbolic-ref", "refs/remotes/origin/HEAD"], cachePath)).replace("refs/remotes/origin/", "");
 	await git([
@@ -143,13 +167,12 @@ const updateRepo = async (cachePath, branch) => {
 };
 /**
 * ensures a repository is cloned and up-to-date.
-* @param remote the remote URL
-* @param cachePath the local cache path
-* @param branch optional branch to checkout
+* @param options repository options
 */
-const ensureRepo = async (remote, cachePath, branch) => {
-	if (existsSync(cachePath)) await updateRepo(cachePath, branch);
-	else await cloneRepo(remote, cachePath, branch);
+const ensureRepo = async (options) => {
+	const { remote, cachePath, branch, shallow } = options;
+	if (existsSync(cachePath)) await updateRepo(cachePath, branch, shallow);
+	else await cloneRepo(remote, cachePath, branch, shallow);
 };
 
 //#endregion
@@ -315,6 +338,7 @@ const schema$1 = object({
 		"sonnet",
 		"haiku"
 	]), { description: message`model to use for analysis` }), "haiku"),
+	shallow: flag("-s", "--shallow", { description: message`use shallow clone (depth 1) to save time and disk space` }),
 	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` }),
@@ -420,7 +444,12 @@ const handler$1 = async (args) => {
 		const remoteUrl = normalizeRemote(mainRepo.remote);
 		console.error(`preparing repository: ${mainRepo.parsed.host}/${mainRepo.parsed.path}`);
 		try {
-			await ensureRepo(remoteUrl, mainRepo.cachePath, mainRepo.branch);
+			await ensureRepo({
+				remote: remoteUrl,
+				cachePath: mainRepo.cachePath,
+				branch: mainRepo.branch,
+				shallow: args.shallow
+			});
 		} catch (err) {
 			console.error(`error: failed to prepare repository: ${err}`);
 			process.exit(1);
@@ -435,7 +464,12 @@ const handler$1 = async (args) => {
 		const remoteUrl = normalizeRemote(repo.remote);
 		const display = `${repo.parsed.host}/${repo.parsed.path}`;
 		console.error(`  preparing: ${display}`);
-		await ensureRepo(remoteUrl, repo.cachePath, repo.branch);
+		await ensureRepo({
+			remote: remoteUrl,
+			cachePath: repo.cachePath,
+			branch: repo.branch,
+			shallow: args.shallow
+		});
 		return repo;
 	}));
 	const failures = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oomfware/cgr",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "ask questions about git repositories using Claude Code",
   "license": "0BSD",
   "repository": {

package/src/commands/ask.ts

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { join } from 'node:path';
 
-import { argument, choice, constant, type InferValue, message, object, option, string } from '@optique/core';
+import { argument, choice, constant, flag, type InferValue, message, object, option, string } from '@optique/core';
 import { multiple, optional, withDefault } from '@optique/core/modifiers';
 
 import { ensureRepo } from '../lib/git.ts';
@@ -28,6 +28,9 @@ export const schema = object({
 		}),
 		'haiku',
 	),
+	shallow: flag('-s', '--shallow', {
+		description: message`use shallow clone (depth 1) to save time and disk space`,
+	}),
 	// TODO: deprecated in favor of #branch syntax, remove in future version
 	branch: optional(
 		option('-b', '--branch', string(), {
@@ -168,7 +171,12 @@ export const handler = async (args: Args): Promise<void> => {
 		const remoteUrl = normalizeRemote(mainRepo.remote);
 		console.error(`preparing repository: ${mainRepo.parsed.host}/${mainRepo.parsed.path}`);
 		try {
-			await ensureRepo(remoteUrl, mainRepo.cachePath, mainRepo.branch);
+			await ensureRepo({
+				remote: remoteUrl,
+				cachePath: mainRepo.cachePath,
+				branch: mainRepo.branch,
+				shallow: args.shallow,
+			});
 		} catch (err) {
 			console.error(`error: failed to prepare repository: ${err}`);
 			process.exit(1);
@@ -192,7 +200,12 @@ export const handler = async (args: Args): Promise<void> => {
 			const remoteUrl = normalizeRemote(repo.remote);
 			const display = `${repo.parsed.host}/${repo.parsed.path}`;
 			console.error(`  preparing: ${display}`);
-			await ensureRepo(remoteUrl, repo.cachePath, repo.branch);
+			await ensureRepo({
+				remote: remoteUrl,
+				cachePath: repo.cachePath,
+				branch: repo.branch,
+				shallow: args.shallow,
+			});
 			return repo;
 		}),
 	);

package/src/lib/git.ts

@@ -85,15 +85,34 @@ const gitOutput = (args: string[], cwd?: string): Promise<string> =>
 		proc.on('error', reject);
 	});
 
+/**
+ * checks if a repository is a shallow clone.
+ * @param cachePath the local repository path
+ * @returns true if the repository is shallow
+ */
+export const isShallowRepo = async (cachePath: string): Promise<boolean> => {
+	const result = await gitOutput(['rev-parse', '--is-shallow-repository'], cachePath);
+	return result === 'true';
+};
+
 /**
  * clones a repository to the cache path.
  * @param remote the remote URL
  * @param cachePath the local cache path
  * @param branch optional branch to checkout
+ * @param shallow if true, performs a shallow clone with depth 1
  */
-export const cloneRepo = async (remote: string, cachePath: string, branch?: string): Promise<void> => {
+export const cloneRepo = async (
+	remote: string,
+	cachePath: string,
+	branch?: string,
+	shallow?: boolean,
+): Promise<void> => {
 	await mkdir(dirname(cachePath), { recursive: true });
 	const args = ['clone'];
+	if (shallow) {
+		args.push('--depth', '1');
+	}
 	if (branch) {
 		args.push('--branch', branch);
 	}
@@ -106,9 +125,27 @@ export const cloneRepo = async (remote: string, cachePath: string, branch?: stri
  * discards any local modifications, staged changes, and untracked files.
  * @param cachePath the local cache path
  * @param branch optional branch to checkout (uses default branch if not specified)
+ * @param shallow if true, keeps shallow clone; if false, unshallows if needed
  */
-export const updateRepo = async (cachePath: string, branch?: string): Promise<void> => {
-	await git(['fetch', 'origin'], cachePath);
+export const updateRepo = async (cachePath: string, branch?: string, shallow?: boolean): Promise<void> => {
+	const currentlyShallow = await isShallowRepo(cachePath);
+
+	// handle shallow state transitions
+	if (!shallow && currentlyShallow) {
+		// want full history but have shallow - unshallow first
+		await git(['fetch', '--unshallow', 'origin'], cachePath);
+	} else if (shallow && !currentlyShallow) {
+		// want shallow but have full - just use the full clone as-is
+		console.error('  note: repository is already a full clone, use `cgr clean` to re-clone as shallow');
+	}
+
+	// fetch updates (use depth for shallow repos that stay shallow)
+	if (shallow && currentlyShallow) {
+		await git(['fetch', '--depth', '1', 'origin'], cachePath);
+	} else if (!currentlyShallow || !shallow) {
+		// either was unshallowed above, or is/was full
+		await git(['fetch', 'origin'], cachePath);
+	}
 
 	// determine the branch to use
 	let targetBranch = branch;
@@ -125,16 +162,26 @@ export const updateRepo = async (cachePath: string, branch?: string): Promise<vo
 	await git(['reset', '--hard', `origin/${targetBranch}`], cachePath);
 };
 
+export interface EnsureRepoOptions {
+	/** the remote URL */
+	remote: string;
+	/** the local cache path */
+	cachePath: string;
+	/** branch to checkout */
+	branch: string | undefined;
+	/** if true, uses shallow clone with depth 1 */
+	shallow: boolean;
+}
+
 /**
  * ensures a repository is cloned and up-to-date.
- * @param remote the remote URL
- * @param cachePath the local cache path
- * @param branch optional branch to checkout
+ * @param options repository options
  */
-export const ensureRepo = async (remote: string, cachePath: string, branch?: string): Promise<void> => {
+export const ensureRepo = async (options: EnsureRepoOptions): Promise<void> => {
+	const { remote, cachePath, branch, shallow } = options;
 	if (existsSync(cachePath)) {
-		await updateRepo(cachePath, branch);
+		await updateRepo(cachePath, branch, shallow);
 	} else {
-		await cloneRepo(remote, cachePath, branch);
+		await cloneRepo(remote, cachePath, branch, shallow);
 	}
 };