@oh-my-pi/pi-coding-agent 15.8.0 → 15.8.3

package/src/utils/git.ts

@@ -189,11 +189,7 @@ function formatCommandFailure(
 	return `git ${args.join(" ")} failed with exit code ${result.exitCode}`;
 }
 
-async function runCommand(
-	cwd: string,
-	args: readonly string[],
-	options: CommandOptions = {},
-): Promise<GitCommandResult> {
+async function git(cwd: string, args: readonly string[], options: CommandOptions = {}): Promise<GitCommandResult> {
 	const commandArgs = withShortLivedGitConfig(options.readOnly ? withNoOptionalLocks(args) : [...args]);
 	const child = Bun.spawn(["git", ...commandArgs], {
 		cwd,
@@ -248,7 +244,7 @@ async function runChecked(
 	options: CommandOptions = {},
 ): Promise<GitCommandResult> {
 	ensureAvailable();
-	const result = await runCommand(cwd, args, options);
+	const result = await git(cwd, args, options);
 	if (result.exitCode !== 0) {
 		throw new GitCommandError(args, result);
 	}
@@ -269,7 +265,7 @@ async function tryText(
 	options: CommandOptions = {},
 ): Promise<string | undefined> {
 	ensureAvailable();
-	const result = await runCommand(cwd, args, options);
+	const result = await git(cwd, args, options);
 	if (result.exitCode !== 0) return undefined;
 	return result.stdout;
 }
@@ -709,7 +705,7 @@ export const diff = Object.assign(
 	async function diff(cwd: string, options: DiffOptions = {}): Promise<string> {
 		const args = buildDiffArgs(options);
 		if (options.allowFailure) {
-			return (await runCommand(cwd, args, { env: options.env, readOnly: true, signal: options.signal })).stdout;
+			return (await git(cwd, args, { env: options.env, readOnly: true, signal: options.signal })).stdout;
 		}
 		return runText(cwd, args, { env: options.env, readOnly: true, signal: options.signal });
 	},
@@ -741,7 +737,7 @@ export const diff = Object.assign(
 			if (options.cached) args.push("--cached");
 			args.push("--quiet");
 			if (options.files?.length) args.push("--", ...options.files);
-			const result = await runCommand(cwd, args, { readOnly: true, signal: options.signal });
+			const result = await git(cwd, args, { readOnly: true, signal: options.signal });
 			if (result.exitCode === 0) return false;
 			if (result.exitCode === 1) return true;
 			throw new GitCommandError(args, result);
@@ -757,7 +753,7 @@ export const diff = Object.assign(
 			if (options.binary) args.push("--binary");
 			args.push(base, headRef);
 			if (options.allowFailure) {
-				return (await runCommand(cwd, args, { readOnly: true, signal: options.signal })).stdout;
+				return (await git(cwd, args, { readOnly: true, signal: options.signal })).stdout;
 			}
 			return runText(cwd, args, { readOnly: true, signal: options.signal });
 		},
@@ -789,7 +785,7 @@ export const status = Object.assign(
 	{
 		/** Parsed status counts (staged, unstaged, untracked). */
 		async summary(cwd: string, signal?: AbortSignal): Promise<GitStatusSummary | null> {
-			const result = await runCommand(cwd, ["status", "--porcelain"], { readOnly: true, signal });
+			const result = await git(cwd, ["status", "--porcelain"], { readOnly: true, signal });
 			if (result.exitCode !== 0) return null;
 			return parseStatusPorcelain(result.stdout);
 		},
@@ -950,7 +946,7 @@ export const branch = {
 	async current(cwd: string, signal?: AbortSignal): Promise<string | null> {
 		const headState = await resolveHead(cwd);
 		if (headState?.kind === "ref") return headState.branchName ?? headState.ref;
-		const result = await runCommand(cwd, ["symbolic-ref", "--short", "HEAD"], { readOnly: true, signal });
+		const result = await git(cwd, ["symbolic-ref", "--short", "HEAD"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
@@ -966,7 +962,7 @@ export const branch = {
 			}
 		}
 		for (const remoteRef of ["origin/HEAD", "upstream/HEAD"]) {
-			const result = await runCommand(cwd, ["rev-parse", "--abbrev-ref", remoteRef], { readOnly: true, signal });
+			const result = await git(cwd, ["rev-parse", "--abbrev-ref", remoteRef], { readOnly: true, signal });
 			if (result.exitCode !== 0) continue;
 			const branchName = stripRemotePrefix(result.stdout.trim());
 			if (branchName) return branchName;
@@ -995,7 +991,7 @@ export const branch = {
 		name: string,
 		options: { force?: boolean; signal?: AbortSignal } = {},
 	): Promise<boolean> {
-		const result = await runCommand(cwd, ["branch", options.force === false ? "-d" : "-D", name], {
+		const result = await git(cwd, ["branch", options.force === false ? "-d" : "-D", name], {
 			signal: options.signal,
 		});
 		return result.exitCode === 0;
@@ -1038,7 +1034,7 @@ export const remote = {
 	 * needs to resolve, not paper over.
 	 */
 	async add(cwd: string, name: string, url: string, signal?: AbortSignal): Promise<void> {
-		const result = await runCommand(cwd, ["remote", "add", name, url], { signal });
+		const result = await git(cwd, ["remote", "add", name, url], { signal });
 		if (result.exitCode === 0) return;
 		if (REMOTE_ALREADY_EXISTS.test(result.stderr)) {
 			const existing = await remote.url(cwd, name, signal);
@@ -1059,7 +1055,7 @@ export const ref = {
 		if (refName === "HEAD") return (await head.sha(cwd, signal)) !== null;
 		const repository = await resolveRepository(cwd);
 		if (repository && refName.startsWith("refs/")) return (await readRef(repository, refName)) !== null;
-		const result = await runCommand(cwd, ["show-ref", "--verify", "--quiet", refName], { readOnly: true, signal });
+		const result = await git(cwd, ["show-ref", "--verify", "--quiet", refName], { readOnly: true, signal });
 		return result.exitCode === 0;
 	},
 
@@ -1068,7 +1064,7 @@ export const ref = {
 		if (refName === "HEAD") return head.sha(cwd, signal);
 		const repository = await resolveRepository(cwd);
 		if (repository && refName.startsWith("refs/")) return readRef(repository, refName);
-		const result = await runCommand(cwd, ["rev-parse", refName], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", refName], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
@@ -1150,7 +1146,7 @@ export const worktree = {
 		const args = ["worktree", "remove"];
 		if (options.force ?? true) args.push("-f");
 		args.push(worktreePath);
-		const result = await runCommand(cwd, args, { signal: options.signal });
+		const result = await git(cwd, args, { signal: options.signal });
 		return result.exitCode === 0;
 	},
 
@@ -1186,7 +1182,7 @@ export const patch = {
 
 	/** Check if a patch file can be applied cleanly. */
 	async canApply(cwd: string, patchPath: string, options: Omit<PatchOptions, "check"> = {}): Promise<boolean> {
-		const result = await runCommand(cwd, buildApplyArgs(patchPath, { ...options, check: true }), {
+		const result = await git(cwd, buildApplyArgs(patchPath, { ...options, check: true }), {
 			env: options.env,
 			readOnly: true,
 			signal: options.signal,
@@ -1346,7 +1342,7 @@ export const ls = {
 
 	/** List submodule paths (recursive). */
 	async submodules(cwd: string, signal?: AbortSignal): Promise<string[]> {
-		const output = await runCommand(cwd, ["submodule", "--quiet", "foreach", "--recursive", "echo $sm_path"], {
+		const output = await git(cwd, ["submodule", "--quiet", "foreach", "--recursive", "echo $sm_path"], {
 			readOnly: true,
 			signal,
 		});
@@ -1381,14 +1377,14 @@ export const head = {
 	async sha(cwd: string, signal?: AbortSignal): Promise<string | null> {
 		const headState = await head.resolve(cwd);
 		if (headState?.commit) return headState.commit;
-		const result = await runCommand(cwd, ["rev-parse", "HEAD"], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", "HEAD"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
 
 	/** Abbreviated HEAD commit SHA. */
 	async short(cwd: string, length = 7, signal?: AbortSignal): Promise<string | null> {
-		const result = await runCommand(cwd, ["rev-parse", `--short=${length}`, "HEAD"], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", `--short=${length}`, "HEAD"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
@@ -1403,7 +1399,7 @@ export const repo = {
 	async root(cwd: string, signal?: AbortSignal): Promise<string | null> {
 		const repository = await resolveRepository(cwd);
 		if (repository) return repository.repoRoot;
-		const result = await runCommand(cwd, ["rev-parse", "--show-toplevel"], { readOnly: true, signal });
+		const result = await git(cwd, ["rev-parse", "--show-toplevel"], { readOnly: true, signal });
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},

package/src/utils/jj.ts

@@ -0,0 +1,248 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { $which } from "@oh-my-pi/pi-utils";
+import { LRUCache } from "lru-cache/raw";
+
+// ════════════════════════════════════════════════════════════════════════════
+// Types
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Result from a completed `jj` subprocess invocation. */
+export interface JjCommandResult {
+	/** Process exit code reported by `jj`. */
+	exitCode: number;
+	/** Captured standard output as UTF-8 text. */
+	stdout: string;
+	/** Captured standard error as UTF-8 text. */
+	stderr: string;
+}
+
+/** Resolved Jujutsu workspace metadata. */
+export interface JjRepository {
+	/** Root directory containing the `.jj` workspace metadata. */
+	repoRoot: string;
+	/** Path to the shared workspace store directory, resolved through `.jj/repo`'s file indirection for non-default workspaces. */
+	storeDir: string;
+}
+
+/** Options for `jj diff` invocations. */
+export interface DiffOptions {
+	/** Optional file paths to restrict the diff with `-- <files>`. */
+	readonly files?: readonly string[];
+	/** Return only changed file names instead of Git-format diff text. */
+	readonly nameOnly?: boolean;
+	/** Optional abort signal passed to the spawned `jj` process. */
+	readonly signal?: AbortSignal;
+}
+
+interface CommandOptions {
+	readonly signal?: AbortSignal;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Error
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Error thrown when a checked `jj` command exits non-zero. */
+export class JjCommandError extends Error {
+	/** Arguments passed after the common `jj --no-pager --color=never` prefix. */
+	readonly args: readonly string[];
+	/** Captured command result that caused the failure. */
+	readonly result: JjCommandResult;
+
+	/** Create an error for a failed checked `jj` command. */
+	constructor(args: readonly string[], result: JjCommandResult) {
+		super(formatCommandFailure(args, result));
+		this.name = "JjCommandError";
+		this.args = [...args];
+		this.result = result;
+	}
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Internal: Core execution
+// ════════════════════════════════════════════════════════════════════════════
+
+function ensureAvailable(): void {
+	if (!$which("jj")) {
+		throw new Error("jj is not installed.");
+	}
+}
+
+function formatCommandFailure(
+	args: readonly string[],
+	result: Pick<JjCommandResult, "exitCode" | "stdout" | "stderr">,
+): string {
+	const stderr = result.stderr.trim();
+	if (stderr) return stderr;
+	const stdout = result.stdout.trim();
+	if (stdout) return stdout;
+	return `jj ${args.join(" ")} failed with exit code ${result.exitCode}`;
+}
+
+async function jj(cwd: string, args: readonly string[], options: CommandOptions = {}): Promise<JjCommandResult> {
+	const child = Bun.spawn(["jj", "--no-pager", "--color=never", ...args], {
+		cwd,
+		signal: options.signal,
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+		windowsHide: true,
+	});
+
+	if (!child.stdout || !child.stderr) {
+		throw new Error("Failed to capture jj command output.");
+	}
+
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+		child.exited,
+	]);
+
+	return { exitCode: exitCode ?? 0, stdout, stderr };
+}
+
+async function runChecked(
+	cwd: string,
+	args: readonly string[],
+	options: CommandOptions = {},
+): Promise<JjCommandResult> {
+	ensureAvailable();
+	const result = await jj(cwd, args, options);
+	if (result.exitCode !== 0) {
+		throw new JjCommandError(args, result);
+	}
+	return result;
+}
+
+async function runText(cwd: string, args: readonly string[], options: CommandOptions = {}): Promise<string> {
+	return (await runChecked(cwd, args, options)).stdout;
+}
+
+function splitLines(text: string): string[] {
+	return text
+		.split("\n")
+		.map(line => line.trim())
+		.filter(Boolean);
+}
+
+function buildDiffArgs(options: DiffOptions): string[] {
+	const args = ["diff"];
+	args.push(options.nameOnly ? "--name-only" : "--git");
+	if (options.files?.length) args.push("--", ...options.files);
+	return args;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Internal: Repository resolution
+// ════════════════════════════════════════════════════════════════════════════
+
+interface WorkspaceRootCacheEntry {
+	readonly root?: string;
+}
+
+const WORKSPACE_ROOT_CACHE_MAX_ENTRIES = 256;
+const workspaceRootCache = new LRUCache<string, WorkspaceRootCacheEntry>({ max: WORKSPACE_ROOT_CACHE_MAX_ENTRIES });
+
+async function hasJjWorkspaceMetadata(dir: string): Promise<boolean> {
+	// jj marks a directory as a workspace via `.jj/repo`. In the default workspace
+	// it is a directory (containing `store/`, …); in a workspace created by
+	// `jj workspace add` it is a FILE whose contents point at the shared repo dir
+	// of the default workspace. Either form is a real workspace, so match on
+	// `.jj/repo` presence rather than the inner `store/` directory.
+	try {
+		await fs.stat(path.join(dir, ".jj", "repo"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function parentOf(dir: string): string | undefined {
+	const parent = path.dirname(dir);
+	return parent === dir ? undefined : parent;
+}
+
+async function findWorkspaceRoot(cwd: string): Promise<string | undefined> {
+	const key = path.resolve(cwd);
+	if (workspaceRootCache.has(key)) return workspaceRootCache.get(key)?.root;
+
+	for (let dir: string | undefined = key; dir; dir = parentOf(dir)) {
+		if (await hasJjWorkspaceMetadata(dir)) {
+			workspaceRootCache.set(key, { root: dir });
+			return dir;
+		}
+	}
+
+	workspaceRootCache.set(key, {});
+	return undefined;
+}
+
+/**
+ * Resolve the `.jj/repo` directory backing a workspace root, following the file
+ * indirection used by non-default workspaces. `jj workspace add` writes a FILE at
+ * `.jj/repo` whose contents are a path — relative to `.jj` — to the shared repo
+ * directory of the default workspace; the default workspace keeps `.jj/repo` as a
+ * directory.
+ */
+async function resolveRepoDir(root: string): Promise<string> {
+	const jjDir = path.join(root, ".jj");
+	const repoPath = path.join(jjDir, "repo");
+	if ((await fs.stat(repoPath)).isFile()) {
+		const target = (await fs.readFile(repoPath, "utf8")).trim();
+		return path.resolve(jjDir, target);
+	}
+	return repoPath;
+}
+
+async function repositoryFromRoot(root: string): Promise<JjRepository> {
+	return {
+		repoRoot: root,
+		storeDir: path.join(await resolveRepoDir(root), "store"),
+	};
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// API: diff
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Run `jj diff --git` for the current workspace commit and return the raw Git-format diff text. */
+export const diff = Object.assign(
+	async function diff(cwd: string, options: DiffOptions = {}): Promise<string> {
+		return runText(cwd, buildDiffArgs(options), { signal: options.signal });
+	},
+	{
+		/** List changed file paths. */
+		async changedFiles(cwd: string, options: Pick<DiffOptions, "files" | "signal"> = {}): Promise<string[]> {
+			return splitLines(await diff(cwd, { ...options, nameOnly: true }));
+		},
+	},
+);
+
+// ════════════════════════════════════════════════════════════════════════════
+// API: repo
+// ════════════════════════════════════════════════════════════════════════════
+
+export const repo = {
+	/** Clear cached workspace roots. Intended for tests that mutate JJ metadata under an existing path. */
+	clearRootCache(): void {
+		workspaceRootCache.clear();
+	},
+
+	/** Resolve the current Jujutsu workspace root, or `null` when `cwd` is not in a JJ repository. */
+	async root(cwd: string): Promise<string | null> {
+		return (await findWorkspaceRoot(cwd)) ?? null;
+	},
+
+	/** Full Jujutsu workspace metadata. */
+	async resolve(cwd: string): Promise<JjRepository | null> {
+		const root = await repo.root(cwd);
+		return root ? await repositoryFromRoot(root) : null;
+	},
+
+	/** Check whether `cwd` is inside a Jujutsu repository. */
+	async is(cwd: string): Promise<boolean> {
+		return (await repo.root(cwd)) !== null;
+	},
+};