unagent 0.0.3 → 0.0.4

package/dist/{git-BczcRFau.mjs → clone-DgXhqC05.mjs}

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "pathe";
-import { execSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 
 //#region src/git/_exec.ts
 function git(args, opts) {
-	return execSync(`git ${args.join(" ")}`, {
+	const result = spawnSync("git", args, {
 		cwd: opts?.cwd,
 		timeout: opts?.timeout,
 		encoding: "utf8",
@@ -14,7 +14,10 @@ function git(args, opts) {
 			"pipe",
 			"pipe"
 		]
-	}).trim();
+	});
+	if (result.error) throw result.error;
+	if (result.status !== 0) throw new Error(result.stderr || `git ${args[0]} failed with code ${result.status}`);
+	return (result.stdout ?? "").trim();
 }
 function parseGitStatus(output) {
 	const lines = output.split("\n").filter(Boolean);
@@ -98,86 +101,4 @@ function isTempDir(path) {
 }
 
 //#endregion
-//#region src/git/operations.ts
-function getGitStatus(dir) {
-	if (!existsSync(dir)) return void 0;
-	try {
-		git(["rev-parse", "--is-inside-work-tree"], { cwd: dir });
-		const parsed = parseGitStatus(git([
-			"status",
-			"--porcelain=v2",
-			"--branch"
-		], { cwd: dir }));
-		return {
-			isRepo: true,
-			branch: parsed.branch,
-			ahead: parsed.ahead,
-			behind: parsed.behind,
-			staged: parsed.staged,
-			modified: parsed.modified,
-			untracked: parsed.untracked,
-			hasChanges: parsed.staged.length > 0 || parsed.modified.length > 0 || parsed.untracked.length > 0
-		};
-	} catch {
-		return;
-	}
-}
-function getCurrentBranch(dir) {
-	try {
-		return git([
-			"rev-parse",
-			"--abbrev-ref",
-			"HEAD"
-		], { cwd: dir });
-	} catch {
-		return;
-	}
-}
-function checkout(dir, ref) {
-	try {
-		git(["checkout", ref], { cwd: dir });
-		return true;
-	} catch {
-		return false;
-	}
-}
-function pull(dir) {
-	try {
-		git(["pull"], { cwd: dir });
-		return true;
-	} catch {
-		return false;
-	}
-}
-function fetch(dir, remote = "origin") {
-	try {
-		git(["fetch", remote], { cwd: dir });
-		return true;
-	} catch {
-		return false;
-	}
-}
-function getRemoteUrl(dir, remote = "origin") {
-	try {
-		return git([
-			"remote",
-			"get-url",
-			remote
-		], { cwd: dir });
-	} catch {
-		return;
-	}
-}
-function getLatestCommitHash(dir) {
-	try {
-		return git(["rev-parse", "HEAD"], { cwd: dir });
-	} catch {
-		return;
-	}
-}
-function hasUncommittedChanges(dir) {
-	return getGitStatus(dir)?.hasChanges ?? false;
-}
-
-//#endregion
-export { getLatestCommitHash as a, pull as c, cloneRepo as d, cloneToTemp as f, getGitStatus as i, GitCloneError as l, fetch as n, getRemoteUrl as o, isTempDir as p, getCurrentBranch as r, hasUncommittedChanges as s, checkout as t, cleanupTempDir as u };
+export { isTempDir as a, cloneToTemp as i, cleanupTempDir as n, git as o, cloneRepo as r, parseGitStatus as s, GitCloneError as t };

package/dist/context/index.d.mts

@@ -0,0 +1,2 @@
+import { a as TruncateOptions, c as splitByTokens, i as TokenEstimateOptions, l as truncateToFit, n as BuildContextResult, o as buildContext, r as ContextItem, s as estimateTokens, t as BuildContextOptions } from "../index-Bd1gSwMB.mjs";
+export { BuildContextOptions, BuildContextResult, ContextItem, TokenEstimateOptions, TruncateOptions, buildContext, estimateTokens, splitByTokens, truncateToFit };

package/dist/context/index.mjs

@@ -0,0 +1,3 @@
+import { i as truncateToFit, n as estimateTokens, r as splitByTokens, t as buildContext } from "../context-CAk5kS7q.mjs";
+
+export { buildContext, estimateTokens, splitByTokens, truncateToFit };

package/dist/context-CAk5kS7q.mjs

@@ -0,0 +1,59 @@
+//#region src/context/index.ts
+const CHARS_PER_TOKEN = 4;
+function estimateTokens(text, options = {}) {
+	const { charsPerToken = CHARS_PER_TOKEN } = options;
+	return Math.ceil(text.length / charsPerToken);
+}
+function truncateToFit(content, options) {
+	const { maxTokens, charsPerToken = CHARS_PER_TOKEN, suffix = "\n...[truncated]" } = options;
+	const maxChars = maxTokens * charsPerToken;
+	if (content.length <= maxChars) return content;
+	const truncateAt = maxChars - suffix.length;
+	if (truncateAt <= 0) return suffix.slice(0, maxChars);
+	return content.slice(0, truncateAt) + suffix;
+}
+function buildContext(items, options) {
+	const { maxTokens, charsPerToken = CHARS_PER_TOKEN, separator = "\n\n" } = options;
+	const maxChars = maxTokens * charsPerToken;
+	const sorted = [...items].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+	const included = [];
+	const excluded = [];
+	const parts = [];
+	let currentChars = 0;
+	for (let i = 0; i < sorted.length; i++) {
+		const item = sorted[i];
+		const itemChars = item.content.length;
+		const separatorChars = parts.length > 0 ? separator.length : 0;
+		const totalChars = currentChars + itemChars + separatorChars;
+		if (totalChars <= maxChars) {
+			parts.push(item.content);
+			currentChars = totalChars;
+			included.push(item.id ?? `item-${i}`);
+		} else excluded.push(item.id ?? `item-${i}`);
+	}
+	return {
+		content: parts.join(separator),
+		tokens: estimateTokens(parts.join(separator), { charsPerToken }),
+		included,
+		excluded
+	};
+}
+function splitByTokens(text, maxTokensPerChunk, options = {}) {
+	const { charsPerToken = CHARS_PER_TOKEN } = options;
+	const maxChars = maxTokensPerChunk * charsPerToken;
+	const chunks = [];
+	let start = 0;
+	while (start < text.length) {
+		let end = Math.min(start + maxChars, text.length);
+		if (end < text.length) {
+			const newlineIdx = text.lastIndexOf("\n", end);
+			if (newlineIdx > start) end = newlineIdx + 1;
+		}
+		chunks.push(text.slice(start, end));
+		start = end;
+	}
+	return chunks;
+}
+
+//#endregion
+export { truncateToFit as i, estimateTokens as n, splitByTokens as r, buildContext as t };

package/dist/{env-BcNA2wGd.mjs → detect-CDtKsCsD.mjs}

@@ -1,4 +1,4 @@
-import { t as expandPath } from "./path-D5oePhrf.mjs";
+import { t as expandPath } from "./path-Dm-URQvz.mjs";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "pathe";

package/dist/env/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as getAgentConfig, a as getAgentSkillsDir, c as isCI, d as detectAgentByEnv, f as detectCurrentAgent, g as agents, h as AgentConfig, i as getAgentRulesPath, l as isTTY, m as isRunningInAgent, n as agentConfigExists, o as getXDGPaths, p as detectInstalledAgents, r as getAgentConfigDir, s as hasTTY, t as XDGPaths, u as DetectedAgent, v as getAgentIds, y as getAllAgents } from "../index-Bzc-AUnz.mjs";
+import { _ as getAgentConfig, a as getAgentSkillsDir, c as isCI, d as detectAgentByEnv, f as detectCurrentAgent, g as agents, h as AgentConfig, i as getAgentRulesPath, l as isTTY, m as isRunningInAgent, n as agentConfigExists, o as getXDGPaths, p as detectInstalledAgents, r as getAgentConfigDir, s as hasTTY, t as XDGPaths, u as DetectedAgent, v as getAgentIds, y as getAllAgents } from "../index-CzgY9GU2.mjs";
 export { AgentConfig, DetectedAgent, XDGPaths, agentConfigExists, agents, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getXDGPaths, hasTTY, isCI, isRunningInAgent, isTTY };

package/dist/env/index.mjs

@@ -1,4 +1,5 @@
-import { a as agentConfigExists, c as getAgentSkillsDir, d as isCI, f as isTTY, g as getAllAgents, h as getAgentIds, i as isRunningInAgent, l as getXDGPaths, m as getAgentConfig, n as detectCurrentAgent, o as getAgentConfigDir, p as agents, r as detectInstalledAgents, s as getAgentRulesPath, t as detectAgentByEnv, u as hasTTY } from "../env-BcNA2wGd.mjs";
-import "../path-D5oePhrf.mjs";
+import { a as agentConfigExists, c as getAgentSkillsDir, d as isCI, f as isTTY, g as getAllAgents, h as getAgentIds, i as isRunningInAgent, l as getXDGPaths, m as getAgentConfig, n as detectCurrentAgent, o as getAgentConfigDir, p as agents, r as detectInstalledAgents, s as getAgentRulesPath, t as detectAgentByEnv, u as hasTTY } from "../detect-CDtKsCsD.mjs";
+import "../path-Dm-URQvz.mjs";
+import "../env-DeXFcrWN.mjs";
 
 export { agentConfigExists, agents, detectAgentByEnv, detectCurrentAgent, detectInstalledAgents, getAgentConfig, getAgentConfigDir, getAgentIds, getAgentRulesPath, getAgentSkillsDir, getAllAgents, getXDGPaths, hasTTY, isCI, isRunningInAgent, isTTY };

package/dist/env-DeXFcrWN.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/exec/index.d.mts

@@ -0,0 +1,2 @@
+import { i as execSafeSync, n as ExecResult, r as execSafe, t as ExecOptions } from "../index-C0ulBa5T.mjs";
+export { ExecOptions, ExecResult, execSafe, execSafeSync };

package/dist/exec/index.mjs

@@ -0,0 +1,3 @@
+import { n as execSafeSync, t as execSafe } from "../exec-Dzl5r4Ui.mjs";
+
+export { execSafe, execSafeSync };

package/dist/exec-Dzl5r4Ui.mjs

@@ -0,0 +1,116 @@
+import { spawn, spawnSync } from "node:child_process";
+
+//#region src/exec/index.ts
+const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_MAX_OUTPUT = 1e5;
+function execSafe(command, args, options = {}) {
+	const { cwd, timeout = DEFAULT_TIMEOUT, maxOutput = DEFAULT_MAX_OUTPUT, env, stdin } = options;
+	return new Promise((resolve) => {
+		let stdout = "";
+		let stderr = "";
+		let truncated = false;
+		let timedOut = false;
+		let timeoutId;
+		const proc = spawn(command, args, {
+			cwd,
+			env: env ? {
+				...process.env,
+				...env
+			} : process.env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		const truncateOutput = (current, chunk) => {
+			const combined = current + chunk;
+			if (combined.length > maxOutput) {
+				truncated = true;
+				return combined.slice(0, maxOutput);
+			}
+			return combined;
+		};
+		proc.stdout?.on("data", (chunk) => {
+			stdout = truncateOutput(stdout, chunk.toString());
+		});
+		proc.stderr?.on("data", (chunk) => {
+			stderr = truncateOutput(stderr, chunk.toString());
+		});
+		if (stdin !== void 0) {
+			proc.stdin?.write(stdin);
+			proc.stdin?.end();
+		} else proc.stdin?.end();
+		if (timeout > 0) timeoutId = setTimeout(() => {
+			timedOut = true;
+			proc.kill("SIGTERM");
+			setTimeout(() => proc.kill("SIGKILL"), 1e3);
+		}, timeout);
+		proc.on("close", (code, signal) => {
+			if (timeoutId) clearTimeout(timeoutId);
+			resolve({
+				ok: code === 0,
+				code,
+				stdout: stdout.trim(),
+				stderr: stderr.trim(),
+				signal: signal ?? null,
+				truncated,
+				timedOut
+			});
+		});
+		proc.on("error", (err) => {
+			if (timeoutId) clearTimeout(timeoutId);
+			resolve({
+				ok: false,
+				code: null,
+				stdout: stdout.trim(),
+				stderr: err.message,
+				signal: null,
+				truncated,
+				timedOut
+			});
+		});
+	});
+}
+function execSafeSync(command, args, options = {}) {
+	const { cwd, timeout = DEFAULT_TIMEOUT, maxOutput = DEFAULT_MAX_OUTPUT, env } = options;
+	let truncated = false;
+	const result = spawnSync(command, args, {
+		cwd,
+		timeout,
+		env: env ? {
+			...process.env,
+			...env
+		} : process.env,
+		encoding: "utf8",
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		maxBuffer: maxOutput * 2
+	});
+	const timedOut = result.signal === "SIGTERM";
+	let stdout = result.stdout ?? "";
+	let stderr = result.stderr ?? "";
+	if (stdout.length > maxOutput) {
+		stdout = stdout.slice(0, maxOutput);
+		truncated = true;
+	}
+	if (stderr.length > maxOutput) {
+		stderr = stderr.slice(0, maxOutput);
+		truncated = true;
+	}
+	return {
+		ok: result.status === 0,
+		code: result.status,
+		stdout: stdout.trim(),
+		stderr: stderr.trim(),
+		signal: result.signal ?? null,
+		truncated,
+		timedOut
+	};
+}
+
+//#endregion
+export { execSafeSync as n, execSafe as t };

package/dist/fs/index.d.mts

@@ -0,0 +1,2 @@
+import { a as Storage, i as RealFS, n as InMemoryFS, o as VirtualFS, r as OverlayFS, s as createFSFromStorage, t as FileStat } from "../index-DFqD_DAh.mjs";
+export { FileStat, InMemoryFS, OverlayFS, RealFS, Storage, VirtualFS, createFSFromStorage };

package/dist/fs/index.mjs

@@ -0,0 +1,3 @@
+import { i as createFSFromStorage, n as OverlayFS, r as RealFS, t as InMemoryFS } from "../fs-nJz4v9pE.mjs";
+
+export { InMemoryFS, OverlayFS, RealFS, createFSFromStorage };

package/dist/fs-nJz4v9pE.mjs

@@ -0,0 +1,269 @@
+import { dirname, join, normalize } from "pathe";
+import * as nodeFs from "node:fs/promises";
+
+//#region src/fs/index.ts
+function ensureLeadingSlash(path) {
+	return path.startsWith("/") ? path : `/${path}`;
+}
+var InMemoryFS = class {
+	files = /* @__PURE__ */ new Map();
+	dirs = new Set(["/"]);
+	normalizePath(path) {
+		return ensureLeadingSlash(path);
+	}
+	async readFile(path) {
+		const p = this.normalizePath(path);
+		const content = this.files.get(p);
+		if (content === void 0) throw new Error(`ENOENT: no such file: ${p}`);
+		return content;
+	}
+	async writeFile(path, content) {
+		const p = this.normalizePath(path);
+		const dir = dirname(p);
+		if (dir !== "/" && !this.dirs.has(dir)) throw new Error(`ENOENT: no such directory: ${dir}`);
+		this.files.set(p, content);
+	}
+	async exists(path) {
+		const p = this.normalizePath(path);
+		return this.files.has(p) || this.dirs.has(p);
+	}
+	async readdir(path) {
+		const p = this.normalizePath(path);
+		if (!this.dirs.has(p)) throw new Error(`ENOENT: no such directory: ${p}`);
+		const entries = /* @__PURE__ */ new Set();
+		const prefix = p === "/" ? "/" : `${p}/`;
+		for (const filePath of this.files.keys()) if (filePath.startsWith(prefix)) {
+			const name = filePath.slice(prefix.length).split("/")[0];
+			if (name) entries.add(name);
+		}
+		for (const dirPath of this.dirs) if (dirPath.startsWith(prefix) && dirPath !== p) {
+			const name = dirPath.slice(prefix.length).split("/")[0];
+			if (name) entries.add(name);
+		}
+		return [...entries];
+	}
+	async mkdir(path, options) {
+		const p = this.normalizePath(path);
+		if (this.dirs.has(p)) return;
+		if (options?.recursive) {
+			const parts = p.split("/").filter(Boolean);
+			let current = "";
+			for (const part of parts) {
+				current += `/${part}`;
+				this.dirs.add(current);
+			}
+		} else {
+			const parent = dirname(p);
+			if (parent !== "/" && !this.dirs.has(parent)) throw new Error(`ENOENT: no such directory: ${parent}`);
+			this.dirs.add(p);
+		}
+	}
+	async rm(path, options) {
+		const p = this.normalizePath(path);
+		if (this.files.has(p)) {
+			this.files.delete(p);
+			return;
+		}
+		if (!this.dirs.has(p)) throw new Error(`ENOENT: no such file or directory: ${p}`);
+		const prefix = p === "/" ? "/" : `${p}/`;
+		if (([...this.files.keys()].some((f) => f.startsWith(prefix)) || [...this.dirs].some((d) => d.startsWith(prefix) && d !== p)) && !options?.recursive) throw new Error(`ENOTEMPTY: directory not empty: ${p}`);
+		for (const filePath of this.files.keys()) if (filePath.startsWith(prefix)) this.files.delete(filePath);
+		for (const dirPath of this.dirs) if (dirPath.startsWith(prefix) || dirPath === p) this.dirs.delete(dirPath);
+	}
+	async stat(path) {
+		const p = this.normalizePath(path);
+		if (this.files.has(p)) return {
+			size: this.files.get(p).length,
+			isFile: true,
+			isDirectory: false
+		};
+		if (this.dirs.has(p)) return {
+			size: 0,
+			isFile: false,
+			isDirectory: true
+		};
+		throw new Error(`ENOENT: no such file or directory: ${p}`);
+	}
+};
+var OverlayFS = class {
+	overlay;
+	deleted = /* @__PURE__ */ new Set();
+	constructor(base) {
+		this.base = base;
+		this.overlay = new InMemoryFS();
+	}
+	normalizePath(path) {
+		return ensureLeadingSlash(path);
+	}
+	async readFile(path) {
+		const p = this.normalizePath(path);
+		if (this.deleted.has(p)) throw new Error(`ENOENT: no such file: ${p}`);
+		try {
+			return await this.overlay.readFile(p);
+		} catch {
+			return await this.base.readFile(p);
+		}
+	}
+	async writeFile(path, content) {
+		const p = this.normalizePath(path);
+		this.deleted.delete(p);
+		const dir = dirname(p);
+		if (dir !== "/") try {
+			await this.overlay.mkdir(dir, { recursive: true });
+		} catch {}
+		await this.overlay.writeFile(p, content);
+	}
+	async exists(path) {
+		const p = this.normalizePath(path);
+		if (this.deleted.has(p)) return false;
+		if (await this.overlay.exists(p)) return true;
+		return await this.base.exists(p);
+	}
+	async readdir(path) {
+		const p = this.normalizePath(path);
+		const entries = /* @__PURE__ */ new Set();
+		try {
+			for (const e of await this.base.readdir(p)) entries.add(e);
+		} catch {}
+		try {
+			for (const e of await this.overlay.readdir(p)) entries.add(e);
+		} catch {}
+		for (const deleted of this.deleted) {
+			const prefix = p === "/" ? "/" : `${p}/`;
+			if (deleted.startsWith(prefix)) {
+				const name = deleted.slice(prefix.length).split("/")[0];
+				if (name && !deleted.slice(prefix.length).includes("/")) entries.delete(name);
+			}
+		}
+		return [...entries];
+	}
+	async mkdir(path, options) {
+		const p = this.normalizePath(path);
+		this.deleted.delete(p);
+		await this.overlay.mkdir(p, options);
+	}
+	async rm(path, options) {
+		const p = this.normalizePath(path);
+		try {
+			await this.overlay.rm(p, options);
+		} catch {}
+		this.deleted.add(p);
+		if (options?.recursive) {
+			const prefix = p === "/" ? "/" : `${p}/`;
+			for (const deleted of [...this.deleted]) if (deleted.startsWith(prefix)) this.deleted.add(deleted);
+		}
+	}
+	async stat(path) {
+		const p = this.normalizePath(path);
+		if (this.deleted.has(p)) throw new Error(`ENOENT: no such file or directory: ${p}`);
+		try {
+			return await this.overlay.stat(p);
+		} catch {
+			return await this.base.stat(p);
+		}
+	}
+};
+var RealFS = class {
+	normalizedBase;
+	constructor(basePath = "/") {
+		this.basePath = basePath;
+		this.normalizedBase = normalize(basePath);
+	}
+	resolve(path) {
+		const resolved = normalize(join(this.basePath, path));
+		if (!resolved.startsWith(this.normalizedBase) && resolved !== this.normalizedBase) throw new Error(`EACCES: path traversal not allowed: ${path}`);
+		return resolved;
+	}
+	async readFile(path) {
+		return await nodeFs.readFile(this.resolve(path), "utf-8");
+	}
+	async writeFile(path, content) {
+		await nodeFs.writeFile(this.resolve(path), content, "utf-8");
+	}
+	async exists(path) {
+		try {
+			await nodeFs.access(this.resolve(path));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async readdir(path) {
+		return await nodeFs.readdir(this.resolve(path));
+	}
+	async mkdir(path, options) {
+		await nodeFs.mkdir(this.resolve(path), options);
+	}
+	async rm(path, options) {
+		await nodeFs.rm(this.resolve(path), options);
+	}
+	async stat(path) {
+		const stats = await nodeFs.stat(this.resolve(path));
+		return {
+			size: stats.size,
+			isFile: stats.isFile(),
+			isDirectory: stats.isDirectory(),
+			mtime: stats.mtime
+		};
+	}
+};
+function createFSFromStorage(storage) {
+	const dirs = new Set(["/"]);
+	return {
+		async readFile(path) {
+			const content = await storage.getItem(path);
+			if (content === null) throw new Error(`ENOENT: no such file: ${path}`);
+			return content;
+		},
+		async writeFile(path, content) {
+			const dir = dirname(path);
+			if (dir !== "/") dirs.add(dir);
+			await storage.setItem(path, content);
+		},
+		async exists(path) {
+			if (dirs.has(path)) return true;
+			return await storage.getItem(path) !== null;
+		},
+		async readdir(path) {
+			const keys = await storage.getKeys(path);
+			const prefix = path === "/" ? "" : path;
+			const entries = /* @__PURE__ */ new Set();
+			for (const key of keys) if (key.startsWith(prefix)) {
+				const name = key.slice(prefix.length).replace(/^\//, "").split("/")[0];
+				if (name) entries.add(name);
+			}
+			return [...entries];
+		},
+		async mkdir(path, options) {
+			if (options?.recursive) {
+				const parts = path.split("/").filter(Boolean);
+				let current = "";
+				for (const part of parts) {
+					current += `/${part}`;
+					dirs.add(current);
+				}
+			} else dirs.add(path);
+		},
+		async rm(path) {
+			await storage.removeItem(path);
+			dirs.delete(path);
+		},
+		async stat(path) {
+			if (dirs.has(path)) return {
+				size: 0,
+				isFile: false,
+				isDirectory: true
+			};
+			const content = await storage.getItem(path);
+			if (content === null) throw new Error(`ENOENT: no such file or directory: ${path}`);
+			return {
+				size: content.length,
+				isFile: true,
+				isDirectory: false
+			};
+		}
+	};
+}
+
+//#endregion
+export { createFSFromStorage as i, OverlayFS as n, RealFS as r, InMemoryFS as t };

package/dist/git/index.d.mts

@@ -1,2 +1,2 @@
-import { a as getGitStatus, c as hasUncommittedChanges, d as CloneResult, f as GitCloneError, g as isTempDir, h as cloneToTemp, i as getCurrentBranch, l as pull, m as cloneRepo, n as checkout, o as getLatestCommitHash, p as cleanupTempDir, r as fetch, s as getRemoteUrl, t as GitStatus, u as CloneOptions } from "../index-C9yyPAid.mjs";
+import { a as getGitStatus, c as hasUncommittedChanges, d as CloneResult, f as GitCloneError, g as isTempDir, h as cloneToTemp, i as getCurrentBranch, l as pull, m as cloneRepo, n as checkout, o as getLatestCommitHash, p as cleanupTempDir, r as fetch, s as getRemoteUrl, t as GitStatus, u as CloneOptions } from "../index-C55JaUgw.mjs";
 export { CloneOptions, CloneResult, GitCloneError, GitStatus, checkout, cleanupTempDir, cloneRepo, cloneToTemp, fetch, getCurrentBranch, getGitStatus, getLatestCommitHash, getRemoteUrl, hasUncommittedChanges, isTempDir, pull };

package/dist/git/index.mjs

@@ -1,3 +1,4 @@
-import { a as getLatestCommitHash, c as pull, d as cloneRepo, f as cloneToTemp, i as getGitStatus, l as GitCloneError, n as fetch, o as getRemoteUrl, p as isTempDir, r as getCurrentBranch, s as hasUncommittedChanges, t as checkout, u as cleanupTempDir } from "../git-BczcRFau.mjs";
+import { a as isTempDir, i as cloneToTemp, n as cleanupTempDir, r as cloneRepo, t as GitCloneError } from "../clone-DgXhqC05.mjs";
+import { a as getLatestCommitHash, c as pull, i as getGitStatus, n as fetch, o as getRemoteUrl, r as getCurrentBranch, s as hasUncommittedChanges, t as checkout } from "../git-D3qsdy9d.mjs";
 
 export { GitCloneError, checkout, cleanupTempDir, cloneRepo, cloneToTemp, fetch, getCurrentBranch, getGitStatus, getLatestCommitHash, getRemoteUrl, hasUncommittedChanges, isTempDir, pull };