unagent 0.0.1 → 0.0.4

package/README.md

@@ -0,0 +1,47 @@
+# unagent
+
+[![npm version](https://img.shields.io/npm/v/unagent?color=f43f5e)](https://npmjs.com/package/unagent)
+[![npm downloads](https://img.shields.io/npm/dm/unagent?color=f43f5e)](https://npmjs.com/package/unagent)
+
+Unified primitives for AI coding agents.
+
+- Detect 45+ AI coding agents by env vars or config
+- Discover and parse markdown-based skill files
+- Parse GitHub/GitLab URLs, owner/repo shortcuts, local paths
+- Clone repos, manage temp dirs, check git status
+- Copy directories, create symlinks safely
+- Track installed skills with lockfile and hashes
+
+## Install
+
+```bash
+npm install unagent
+```
+
+## Usage
+
+```ts
+import { detectCurrentAgent, discoverSkills, parseSource } from 'unagent'
+
+// Detect which agent is running
+const agent = detectCurrentAgent()
+if (agent) {
+  console.log(`Running in ${agent.config.name}`)
+}
+
+// Discover skills
+const skills = discoverSkills('~/.claude/skills', { recursive: true })
+
+// Parse source strings
+parseSource('unjs/unagent') // github
+parseSource('github:user/repo#main') // github with ref
+parseSource('./local/path') // local
+```
+
+## Documentation
+
+[unagent.onmax.me](https://unagent.onmax.me)
+
+## License
+
+MIT

package/dist/clone-DgXhqC05.mjs

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "pathe";
+import { spawnSync } from "node:child_process";
+
+//#region src/git/_exec.ts
+function git(args, opts) {
+	const result = spawnSync("git", args, {
+		cwd: opts?.cwd,
+		timeout: opts?.timeout,
+		encoding: "utf8",
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+	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);
+	const result = {
+		branch: "HEAD",
+		ahead: 0,
+		behind: 0,
+		staged: [],
+		modified: [],
+		untracked: []
+	};
+	for (const line of lines) if (line.startsWith("# branch.head ")) result.branch = line.slice(14);
+	else if (line.startsWith("# branch.ab ")) {
+		const match = line.match(/\+(\d+) -(\d+)/);
+		if (match) {
+			result.ahead = Number.parseInt(match[1], 10);
+			result.behind = Number.parseInt(match[2], 10);
+		}
+	} else if (line.startsWith("1 ") || line.startsWith("2 ")) {
+		const xy = line.slice(2, 4);
+		const path = line.split("	").pop() || line.split(" ").pop() || "";
+		if (xy[0] !== ".") result.staged.push(path);
+		if (xy[1] !== ".") result.modified.push(path);
+	} else if (line.startsWith("? ")) result.untracked.push(line.slice(2));
+	return result;
+}
+
+//#endregion
+//#region src/git/clone.ts
+var GitCloneError = class extends Error {
+	url;
+	cause;
+	constructor(message, url, cause) {
+		super(message);
+		this.name = "GitCloneError";
+		this.url = url;
+		this.cause = cause;
+	}
+};
+function cloneRepo(url, dest, options = {}) {
+	const { depth = 1, branch, timeout = 6e4 } = options;
+	try {
+		const args = ["clone"];
+		if (depth > 0) args.push("--depth", String(depth));
+		if (branch) args.push("--branch", branch);
+		args.push(url, dest);
+		const destDir = join(dest, "..");
+		if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+		git(args, { timeout });
+		return {
+			success: true,
+			path: dest
+		};
+	} catch (error) {
+		return {
+			success: false,
+			path: dest,
+			error: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+function cloneToTemp(url, options = {}) {
+	const { tempDir = tmpdir() } = options;
+	return cloneRepo(url, join(tempDir, `unagent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`), options);
+}
+function cleanupTempDir(path) {
+	const temp = tmpdir();
+	if (!path.startsWith(temp)) return false;
+	try {
+		if (existsSync(path)) rmSync(path, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isTempDir(path) {
+	return path.startsWith(tmpdir());
+}
+
+//#endregion
+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-BUegcU7a.js → detect-CDtKsCsD.mjs}

@@ -1,4 +1,4 @@
-import { t as expandPath } from "./path-nPuHl-f5.js";
+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.ts → 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-BW91Ai1Y.js";
+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.js → 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-BUegcU7a.js";
-import "../path-nPuHl-f5.js";
+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.ts → 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-DwU61LUW.js";
+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

@@ -0,0 +1,4 @@
+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 };