@aigne/afs-fs 1.11.0-beta.10

package/dist/index.cjs

@@ -0,0 +1,1101 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_ripgrep = require('./utils/ripgrep.cjs');
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let node_path = require("node:path");
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
+let ignore = require("ignore");
+ignore = require_rolldown_runtime.__toESM(ignore);
+let js_yaml = require("js-yaml");
+let minimatch = require("minimatch");
+let ufo = require("ufo");
+let zod = require("zod");
+
+//#region src/index.ts
+const LIST_MAX_LIMIT = 1e3;
+/**
+* Wrap fs ENOENT errors with AFSNotFoundError for consistent error handling.
+* Re-throws other errors unchanged.
+*/
+function wrapNotFoundError(error, path) {
+	if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") throw new _aigne_afs.AFSNotFoundError(path);
+	throw error;
+}
+/** Hidden directory name for storing meta data */
+const AFS_META_DIR = ".afs";
+/** Subdirectory for storing file-level meta (to avoid conflicts with directory resources) */
+const AFS_NODES_DIR = ".nodes";
+/** Meta file name */
+const META_FILE = "meta.yaml";
+const afsFSOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
+	name: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	localPath: zod.z.string().describe("The path to the local directory to mount"),
+	description: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("A description of the mounted directory")),
+	ignore: (0, _aigne_afs_utils_zod.optionalize)(zod.z.array(zod.z.string())),
+	useGitignore: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Whether to apply .gitignore rules")),
+	useAfsignore: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Whether to apply .afsignore rules")),
+	accessMode: (0, _aigne_afs_utils_zod.optionalize)(zod.z.enum(["readonly", "readwrite"]).describe("Access mode for this module")),
+	agentSkills: (0, _aigne_afs_utils_zod.optionalize)(zod.z.boolean().describe("Enable automatic agent skill scanning for this module"))
+}));
+var AFSFS = class AFSFS extends _aigne_afs.AFSBaseProvider {
+	static schema() {
+		return afsFSOptionsSchema;
+	}
+	static manifest() {
+		return {
+			name: "fs",
+			description: "Local filesystem directory access.\n- Browse directories, read/write files, search content by pattern\n- Exec actions: `archive` (create tar.gz/zip), `checksum` (MD5/SHA)\n- Path structure: direct filesystem paths (e.g., `/docs/guide.md`)",
+			uriTemplate: "fs://{localPath+}",
+			category: "storage",
+			schema: zod.z.object({ localPath: zod.z.string() }),
+			tags: ["local", "filesystem"]
+		};
+	}
+	static async load({ basePath, config } = {}) {
+		return new AFSFS({
+			...await AFSFS.schema().parseAsync(config),
+			cwd: basePath
+		});
+	}
+	name;
+	description;
+	accessMode;
+	constructor(options) {
+		super();
+		this.options = options;
+		(0, _aigne_afs_utils_zod.zodParse)(afsFSOptionsSchema, options);
+		let localPath;
+		if (options.localPath === ".") localPath = process.cwd();
+		else {
+			localPath = options.localPath.replaceAll("${CWD}", process.cwd());
+			if (localPath.startsWith("~/")) localPath = (0, node_path.join)(process.env.HOME || "", localPath.slice(2));
+			if (!(0, node_path.isAbsolute)(localPath)) localPath = (0, node_path.join)(options.cwd || process.cwd(), localPath);
+		}
+		if (!(0, node_fs.existsSync)(localPath)) (0, node_fs.mkdirSync)(localPath, { recursive: true });
+		this.name = options.name || (0, node_path.basename)(localPath) || "fs";
+		this.description = options.description;
+		this.agentSkills = options.agentSkills;
+		this.accessMode = options.accessMode ?? (options.agentSkills ? "readonly" : "readwrite");
+		this.options.localPath = localPath;
+		this.useGitignore = options.useGitignore ?? false;
+		this.useAfsignore = options.useAfsignore ?? true;
+	}
+	agentSkills;
+	/** Whether to apply .gitignore rules (default: false) */
+	useGitignore;
+	/** Whether to apply .afsignore rules (default: true) */
+	useAfsignore;
+	get localPathExists() {
+		return (0, node_fs_promises.stat)(this.options.localPath).then(() => true).catch(() => false);
+	}
+	/**
+	* Detect MIME type based on file extension
+	*/
+	getMimeType(filePath) {
+		return {
+			png: "image/png",
+			jpg: "image/jpeg",
+			jpeg: "image/jpeg",
+			gif: "image/gif",
+			bmp: "image/bmp",
+			webp: "image/webp",
+			svg: "image/svg+xml",
+			ico: "image/x-icon",
+			pdf: "application/pdf",
+			txt: "text/plain",
+			md: "text/markdown",
+			js: "text/javascript",
+			ts: "text/typescript",
+			json: "application/json",
+			html: "text/html",
+			css: "text/css",
+			xml: "text/xml"
+		}[(0, node_path.basename)(filePath).split(".").pop()?.toLowerCase() || ""] || "application/octet-stream";
+	}
+	/**
+	* Check if file is likely binary based on extension
+	*/
+	isBinaryFile(filePath) {
+		const ext = (0, node_path.basename)(filePath).split(".").pop()?.toLowerCase();
+		return [
+			"png",
+			"jpg",
+			"jpeg",
+			"gif",
+			"bmp",
+			"webp",
+			"ico",
+			"pdf",
+			"zip",
+			"tar",
+			"gz",
+			"exe",
+			"dll",
+			"so",
+			"dylib",
+			"wasm"
+		].includes(ext || "");
+	}
+	/**
+	* Check if a segment is the hidden .afs directory
+	*/
+	isHiddenAfsDir(segment) {
+		return segment === AFS_META_DIR;
+	}
+	/**
+	* Get the physical storage path for a meta operation.
+	*
+	* Virtual path mapping:
+	* - /dir/.meta → /dir/.afs/meta.yaml
+	* - /dir/file.txt/.meta → /dir/.afs/.nodes/file.txt/meta.yaml
+	*/
+	getMetaStoragePath(nodePath, isDirectory) {
+		const mountRoot = this.options.localPath;
+		const normalizedNodePath = nodePath === "/" ? "" : nodePath;
+		const nodeFullPath = (0, node_path.join)(mountRoot, normalizedNodePath);
+		const parentDir = (0, node_path.dirname)(nodeFullPath);
+		const nodeName = (0, node_path.basename)(nodeFullPath);
+		if (isDirectory || normalizedNodePath === "") return (0, node_path.join)(nodeFullPath, AFS_META_DIR, META_FILE);
+		return (0, node_path.join)(parentDir, AFS_META_DIR, AFS_NODES_DIR, nodeName, META_FILE);
+	}
+	/**
+	* Check if a node is a directory (exists and is directory)
+	*/
+	async isNodeDirectory(nodePath) {
+		const mountRoot = this.options.localPath;
+		const fullPath = (0, node_path.join)(mountRoot, nodePath === "/" ? "" : nodePath);
+		try {
+			return (await (0, node_fs_promises.stat)(fullPath)).isDirectory();
+		} catch {
+			return nodePath === "/";
+		}
+	}
+	/**
+	* Load meta object from storage (returns null if not found)
+	*/
+	async loadMeta(nodePath) {
+		try {
+			const isDir = await this.isNodeDirectory(nodePath);
+			return (0, js_yaml.load)(await (0, node_fs_promises.readFile)(this.getMetaStoragePath(nodePath, isDir), "utf8"));
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Save metadata to meta.yaml (merges with existing)
+	* Used internally by writeHandler to persist user metadata
+	*/
+	async saveMeta(nodePath, meta) {
+		const isDir = await this.isNodeDirectory(nodePath);
+		const storagePath = this.getMetaStoragePath(nodePath, isDir);
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(storagePath), { recursive: true });
+		let existingMeta = {};
+		const existing = await this.loadMeta(nodePath);
+		if (existing) existingMeta = existing;
+		await (0, node_fs_promises.writeFile)(storagePath, (0, js_yaml.dump)({
+			...existingMeta,
+			...meta
+		}), "utf8");
+	}
+	/**
+	* Read meta for a node silently (returns undefined if no meta exists).
+	* Used internally by list/search/read methods.
+	*/
+	async getNodeMeta(nodePath) {
+		const meta = await this.loadMeta(nodePath);
+		if (!meta) return;
+		return {
+			meta,
+			kind: typeof meta.kind === "string" ? meta.kind : void 0
+		};
+	}
+	async symlinkToPhysical(path) {
+		if (await this.localPathExists) await (0, node_fs_promises.symlink)(this.options.localPath, path);
+	}
+	async readMetaHandler(ctx) {
+		const nodePath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		const metaPath = (0, ufo.joinURL)(nodePath, ".meta");
+		const nodeFullPath = (0, node_path.join)(this.options.localPath, nodePath);
+		let nodeStats;
+		try {
+			nodeStats = await (0, node_fs_promises.stat)(nodeFullPath);
+		} catch (error) {
+			wrapNotFoundError(error, metaPath);
+		}
+		const isDir = nodeStats.isDirectory();
+		const storagePath = this.getMetaStoragePath(nodePath, isDir);
+		let meta = {};
+		let metaStats = null;
+		try {
+			metaStats = await (0, node_fs_promises.stat)(storagePath);
+			meta = (0, js_yaml.load)(await (0, node_fs_promises.readFile)(storagePath, "utf8")) || {};
+		} catch {}
+		return {
+			id: nodePath,
+			path: metaPath,
+			createdAt: metaStats?.birthtime ?? nodeStats.birthtime,
+			updatedAt: metaStats?.mtime ?? nodeStats.mtime,
+			meta
+		};
+	}
+	async listHandler(ctx) {
+		const options = ctx.options;
+		const path = (0, node_path.join)("/", ctx.path);
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const maxChildren = typeof options?.maxChildren === "number" ? options.maxChildren : Number.MAX_SAFE_INTEGER;
+		const pattern = options?.pattern;
+		const mountRoot = this.options.localPath;
+		if (!(await (0, node_fs_promises.stat)(mountRoot)).isDirectory()) return { data: [] };
+		const fullPath = (0, node_path.join)(mountRoot, path.slice(1));
+		if (typeof maxChildren === "number" && maxChildren <= 0) throw new Error(`Invalid maxChildren: ${maxChildren}. Must be positive.`);
+		const entries = [];
+		const noExpandPaths = [];
+		let stats;
+		try {
+			stats = await (0, node_fs_promises.stat)(fullPath);
+		} catch (error) {
+			wrapNotFoundError(error, path);
+		}
+		if (!stats.isDirectory()) return { data: [] };
+		const items = (await (0, node_fs_promises.readdir)(fullPath)).sort().filter((name) => !this.isHiddenAfsDir(name));
+		const ignoreResult = await this.loadIgnoreRules(fullPath, mountRoot);
+		const ig = ignoreResult?.ig || null;
+		const ignoreBase = ignoreResult?.ignoreBase || mountRoot;
+		const mountIgnorePatterns = ignoreResult?.mountIgnorePatterns || [];
+		const negationPatterns = ignoreResult?.negationPatterns || [];
+		const itemsToProcess = items.length > maxChildren ? items.slice(0, maxChildren) : items;
+		for (const childName of itemsToProcess) {
+			if (entries.length >= limit) break;
+			const childFullPath = (0, node_path.join)(fullPath, childName);
+			const childRelativePath = (0, node_path.join)(path, childName);
+			const itemRelativePath = (0, node_path.relative)(ignoreBase, childFullPath);
+			let isIgnored = false;
+			if (this.isIgnoredByMountPatterns(itemRelativePath, mountIgnorePatterns)) isIgnored = true;
+			else if (this.isNegatedByPatterns(itemRelativePath, negationPatterns)) isIgnored = false;
+			else if (ig) isIgnored = ig.ignores(itemRelativePath) || ig.ignores(`${itemRelativePath}/`);
+			let childStats;
+			try {
+				childStats = await (0, node_fs_promises.stat)(childFullPath);
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			const childIsDirectory = childStats.isDirectory();
+			if (isIgnored && !childIsDirectory) continue;
+			let childrenCount;
+			if (childIsDirectory) {
+				try {
+					childrenCount = (await (0, node_fs_promises.readdir)(childFullPath)).filter((n) => !this.isHiddenAfsDir(n)).length;
+				} catch (err) {
+					if (err.code === "ENOENT") continue;
+					throw err;
+				}
+				if (isIgnored) {
+					if (!this.hasNegatedDescendants(itemRelativePath, negationPatterns)) noExpandPaths.push(childRelativePath);
+				}
+			}
+			const nodeMeta = await this.getNodeMeta(childRelativePath);
+			const meta = {
+				...nodeMeta?.meta,
+				childrenCount,
+				size: childStats.size,
+				kind: nodeMeta?.kind ?? (childIsDirectory ? "fs:directory" : "fs:file")
+			};
+			if (!childIsDirectory) meta.mimeType = this.getMimeType(childFullPath);
+			const entry = {
+				id: childRelativePath,
+				path: childRelativePath,
+				createdAt: childStats.birthtime,
+				updatedAt: childStats.mtime,
+				meta
+			};
+			if (!pattern || (0, minimatch.minimatch)(childRelativePath, pattern, { matchBase: true })) entries.push(entry);
+		}
+		return {
+			data: entries,
+			noExpand: noExpandPaths.length > 0 ? noExpandPaths : void 0
+		};
+	}
+	async readHandler(ctx) {
+		const path = ctx.path;
+		const normalizedPath = (0, node_path.join)("/", path);
+		if (path.split("/").filter(Boolean).some((seg) => this.isHiddenAfsDir(seg))) return;
+		const mountRoot = this.options.localPath;
+		const mountStats = await (0, node_fs_promises.stat)(mountRoot);
+		let fullPath;
+		let stats;
+		try {
+			if (!mountStats.isDirectory()) {
+				if (normalizedPath !== "/") return;
+				fullPath = mountRoot;
+				stats = mountStats;
+			} else {
+				fullPath = (0, node_path.join)(mountRoot, path);
+				stats = await (0, node_fs_promises.stat)(fullPath);
+			}
+		} catch (error) {
+			wrapNotFoundError(error, normalizedPath);
+		}
+		let content;
+		const nodeMeta = await this.getNodeMeta(normalizedPath);
+		const meta = {
+			size: stats.size,
+			...nodeMeta?.meta,
+			kind: nodeMeta?.kind
+		};
+		if (stats.isDirectory()) meta.childrenCount = (await (0, node_fs_promises.readdir)(fullPath)).filter((c) => !this.isHiddenAfsDir(c)).length;
+		else if (stats.isFile()) {
+			const mimeType = this.getMimeType(fullPath);
+			const isBinary = this.isBinaryFile(fullPath);
+			meta.mimeType = mimeType;
+			if (isBinary) {
+				content = (await (0, node_fs_promises.readFile)(fullPath)).toString("base64");
+				meta.contentType = "base64";
+			} else content = await (0, node_fs_promises.readFile)(fullPath, "utf8");
+		}
+		return {
+			id: normalizedPath,
+			path: normalizedPath,
+			createdAt: stats.birthtime,
+			updatedAt: stats.mtime,
+			content,
+			meta
+		};
+	}
+	async writeHandler(ctx, entry) {
+		const path = ctx.path;
+		const normalizedPath = (0, node_path.join)("/", path);
+		const options = ctx.options;
+		const fullPath = (0, node_path.join)(this.options.localPath, path);
+		const append = options?.append ?? false;
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(fullPath), { recursive: true });
+		if (entry.content !== void 0) {
+			let contentToWrite;
+			if (typeof entry.content === "string") contentToWrite = entry.content;
+			else contentToWrite = JSON.stringify(entry.content, null, 2);
+			await (0, node_fs_promises.writeFile)(fullPath, contentToWrite, {
+				encoding: "utf8",
+				flag: append ? "a" : "w"
+			});
+		}
+		if (entry.meta && Object.keys(entry.meta).length > 0) {
+			const { size: _size, mimeType: _mime, childrenCount: _cc, ...metaToPersist } = entry.meta;
+			if (Object.keys(metaToPersist).length > 0) await this.saveMeta(path, metaToPersist);
+		}
+		const stats = await (0, node_fs_promises.stat)(fullPath);
+		let finalMetadata = { size: stats.size };
+		const meta = await this.loadMeta(path);
+		if (meta) finalMetadata = {
+			...meta,
+			size: stats.size
+		};
+		return { data: {
+			id: normalizedPath,
+			path: normalizedPath,
+			createdAt: stats.birthtime,
+			updatedAt: stats.mtime,
+			content: entry.content,
+			summary: entry.summary,
+			meta: finalMetadata,
+			userId: entry.userId,
+			sessionId: entry.sessionId,
+			linkTo: entry.linkTo
+		} };
+	}
+	async deleteHandler(ctx) {
+		const path = ctx.path;
+		const displayPath = path === "/" ? "/" : path.slice(1);
+		const options = ctx.options;
+		const fullPath = (0, node_path.join)(this.options.localPath, path);
+		const recursive = options?.recursive ?? false;
+		let stats;
+		try {
+			stats = await (0, node_fs_promises.stat)(fullPath);
+		} catch (error) {
+			wrapNotFoundError(error, path);
+		}
+		if (stats.isDirectory() && !recursive) throw new Error(`Cannot delete directory '${displayPath}' without recursive option. Set recursive: true to delete directories.`);
+		await (0, node_fs_promises.rm)(fullPath, {
+			recursive,
+			force: true
+		});
+		return { message: `Successfully deleted: ${displayPath}` };
+	}
+	async renameHandler(ctx, newPath) {
+		const oldPath = ctx.path;
+		const displayOldPath = oldPath === "/" ? "/" : oldPath.slice(1);
+		const overwrite = ctx.options?.overwrite ?? false;
+		const oldFullPath = (0, node_path.join)(this.options.localPath, oldPath);
+		const newFullPath = (0, node_path.join)(this.options.localPath, newPath);
+		try {
+			await (0, node_fs_promises.stat)(oldFullPath);
+		} catch (error) {
+			wrapNotFoundError(error, oldPath);
+		}
+		try {
+			await (0, node_fs_promises.stat)(newFullPath);
+			if (!overwrite) throw new Error(`Destination '${newPath}' already exists. Set overwrite: true to replace it.`);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(newFullPath), { recursive: true });
+		await (0, node_fs_promises.rename)(oldFullPath, newFullPath);
+		return { message: `Successfully renamed '${displayOldPath}' to '${newPath}'` };
+	}
+	async searchHandler(ctx, query, options) {
+		const path = ctx.path;
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const mountRoot = this.options.localPath;
+		const basePath = (0, node_path.join)(mountRoot, path);
+		try {
+			await (0, node_fs_promises.stat)(basePath);
+		} catch (error) {
+			wrapNotFoundError(error, path);
+		}
+		const matches = await require_ripgrep.searchWithRipgrep(basePath, query, options);
+		const ignoreResult = await this.loadIgnoreRules(basePath, mountRoot);
+		const ig = ignoreResult?.ig || null;
+		const mountIgnorePatterns = ignoreResult?.mountIgnorePatterns || [];
+		const entries = [];
+		const processedFiles = /* @__PURE__ */ new Set();
+		let hasMoreFiles = false;
+		for (const match of matches) if (match.type === "match" && match.data.path) {
+			const absolutePath = match.data.path.text;
+			const itemRelativePath = (0, node_path.join)(path, (0, node_path.relative)(basePath, absolutePath));
+			const pathFromRoot = (0, node_path.relative)(mountRoot, absolutePath);
+			if (this.isIgnoredByMountPatterns(pathFromRoot, mountIgnorePatterns)) continue;
+			if (ig && (ig.ignores(pathFromRoot) || ig.ignores(`${pathFromRoot}/`))) continue;
+			if (processedFiles.has(itemRelativePath)) continue;
+			processedFiles.add(itemRelativePath);
+			const normalizedEntryPath = (0, node_path.join)("/", itemRelativePath);
+			const stats = await (0, node_fs_promises.stat)(absolutePath);
+			const nodeMeta = await this.getNodeMeta(itemRelativePath);
+			const entry = {
+				id: normalizedEntryPath,
+				path: normalizedEntryPath,
+				createdAt: stats.birthtime,
+				updatedAt: stats.mtime,
+				summary: match.data.lines?.text,
+				meta: {
+					size: stats.size,
+					...nodeMeta?.meta,
+					kind: nodeMeta?.kind
+				}
+			};
+			entries.push(entry);
+			if (entries.length >= limit) {
+				hasMoreFiles = true;
+				break;
+			}
+		}
+		return {
+			data: entries,
+			message: hasMoreFiles ? `Results truncated to limit ${limit}` : void 0
+		};
+	}
+	async statHandler(ctx) {
+		const normalizedPath = ctx.path;
+		if (normalizedPath.split("/").filter(Boolean).some((seg) => this.isHiddenAfsDir(seg))) throw new Error("Access denied: .afs is a hidden directory");
+		const fullPath = (0, node_path.join)(this.options.localPath, normalizedPath);
+		let stats;
+		try {
+			stats = await (0, node_fs_promises.stat)(fullPath);
+		} catch (error) {
+			wrapNotFoundError(error, normalizedPath);
+		}
+		const meta = { ...await this.loadMeta(normalizedPath) };
+		if (stats.isFile()) meta.size = stats.size;
+		else if (stats.isDirectory()) meta.childrenCount = (await (0, node_fs_promises.readdir)(fullPath)).filter((c) => !this.isHiddenAfsDir(c)).length;
+		return { data: {
+			id: (0, node_path.basename)(normalizedPath) || "/",
+			path: normalizedPath,
+			updatedAt: stats.mtime,
+			createdAt: stats.birthtime,
+			meta
+		} };
+	}
+	async explainHandler(ctx) {
+		const normalizedPath = ctx.path;
+		const format = ctx.options?.format || "markdown";
+		if (normalizedPath.split("/").filter(Boolean).some((seg) => this.isHiddenAfsDir(seg))) throw new Error("Access denied: .afs is a hidden directory");
+		const fullPath = (0, node_path.join)(this.options.localPath, normalizedPath);
+		const stats = await (0, node_fs_promises.stat)(fullPath);
+		const isDir = stats.isDirectory();
+		const nodeName = (0, node_path.basename)(normalizedPath) || "/";
+		const meta = await this.loadMeta(normalizedPath);
+		let kindSchema;
+		if (meta?.kind && typeof meta.kind === "string") kindSchema = (0, _aigne_afs.resolveKindSchema)(meta.kind);
+		let children = [];
+		if (isDir) children = (await (0, node_fs_promises.readdir)(fullPath)).filter((item) => !this.isHiddenAfsDir(item)).sort();
+		const lines = [];
+		if (format === "markdown") {
+			lines.push(`# ${nodeName}`);
+			lines.push("");
+			lines.push(`**Path:** \`${normalizedPath}\``);
+			lines.push(`**Type:** ${isDir ? "directory" : "file"}`);
+			if (!isDir) lines.push(`**Size:** ${stats.size} bytes`);
+			if (meta) {
+				lines.push("");
+				lines.push("## Metadata");
+				if (meta.kind) lines.push(`**Kind:** \`${meta.kind}\``);
+				if (meta.name) lines.push(`**Name:** ${meta.name}`);
+				if (meta.description) lines.push(`**Description:** ${meta.description}`);
+				const otherProps = Object.entries(meta).filter(([key]) => ![
+					"kind",
+					"name",
+					"description"
+				].includes(key));
+				if (otherProps.length > 0) {
+					lines.push("");
+					for (const [key, value] of otherProps) lines.push(`- **${key}:** ${JSON.stringify(value)}`);
+				}
+			}
+			if (kindSchema) {
+				lines.push("");
+				lines.push("## Kind Schema");
+				lines.push(`This node is of kind \`${kindSchema.name}\`.`);
+				if (kindSchema.description) lines.push(`> ${kindSchema.description}`);
+				if (kindSchema.extends) lines.push(`Extends: \`${kindSchema.extends}\``);
+			}
+			if (isDir && children.length > 0) {
+				lines.push("");
+				lines.push("## Contents");
+				lines.push("");
+				for (const child of children.slice(0, 20)) lines.push(`- ${child}`);
+				if (children.length > 20) lines.push(`- ... and ${children.length - 20} more`);
+			} else if (isDir) {
+				lines.push("");
+				lines.push("*This directory is empty.*");
+			}
+		} else {
+			lines.push(`${nodeName} (${isDir ? "directory" : "file"})`);
+			lines.push(`Path: ${normalizedPath}`);
+			if (!isDir) lines.push(`Size: ${stats.size} bytes`);
+			if (meta) {
+				if (meta.kind) lines.push(`Kind: ${meta.kind}`);
+				if (meta.name) lines.push(`Name: ${meta.name}`);
+				if (meta.description) lines.push(`Description: ${meta.description}`);
+			}
+			if (isDir && children.length > 0) {
+				lines.push("");
+				lines.push("Contents:");
+				for (const child of children.slice(0, 20)) lines.push(`  - ${child}`);
+				if (children.length > 20) lines.push(`  ... and ${children.length - 20} more`);
+			}
+		}
+		return {
+			content: lines.join("\n"),
+			format
+		};
+	}
+	async readCapabilitiesHandler(_ctx) {
+		const operations = [
+			"list",
+			"read",
+			"stat",
+			"explain",
+			"search"
+		];
+		if (this.accessMode === "readwrite") operations.push("write", "delete", "rename");
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				description: this.description || "Local filesystem provider",
+				tools: [],
+				operations: this.getOperationsDeclaration(),
+				actions: [{
+					description: "Directory-level actions",
+					catalog: [{
+						name: "archive",
+						description: "Create a compressed archive (tar.gz or zip) of the directory contents",
+						inputSchema: {
+							type: "object",
+							properties: {
+								format: {
+									type: "string",
+									enum: ["tar.gz", "zip"],
+									description: "Archive format"
+								},
+								pattern: {
+									type: "string",
+									description: "Glob pattern to filter files (e.g., '**/*.ts')"
+								}
+							},
+							required: ["format"]
+						}
+					}],
+					discovery: {
+						pathTemplate: "/:path*/.actions",
+						note: "Archive action available on directories"
+					}
+				}, {
+					description: "File-level actions",
+					catalog: [{
+						name: "checksum",
+						description: "Compute a cryptographic hash of the file content",
+						inputSchema: {
+							type: "object",
+							properties: { algorithm: {
+								type: "string",
+								enum: [
+									"md5",
+									"sha1",
+									"sha256",
+									"sha512"
+								],
+								description: "Hash algorithm to use"
+							} },
+							required: ["algorithm"]
+						}
+					}],
+					discovery: {
+						pathTemplate: "/:path*/.actions",
+						note: "Checksum action available on files"
+					}
+				}]
+			},
+			meta: {
+				kind: "afs:capabilities",
+				operations
+			}
+		};
+	}
+	async archiveAction(ctx, args) {
+		const normalizedPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		const format = args.format;
+		const pattern = args.pattern;
+		const mountRoot = this.options.localPath;
+		if (!format || !["tar.gz", "zip"].includes(format)) return {
+			success: false,
+			error: {
+				code: "INVALID_FORMAT",
+				message: `Unsupported archive format: ${format}. Supported formats: tar.gz, zip`
+			}
+		};
+		const fullPath = (0, node_path.join)(mountRoot, normalizedPath);
+		if (!fullPath.startsWith(mountRoot)) return {
+			success: false,
+			error: {
+				code: "PATH_TRAVERSAL",
+				message: "Path traversal is not allowed"
+			}
+		};
+		let stats;
+		try {
+			stats = await (0, node_fs_promises.stat)(fullPath);
+		} catch {
+			return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Path not found: ${normalizedPath}`
+				}
+			};
+		}
+		if (!stats.isDirectory()) return {
+			success: false,
+			error: {
+				code: "NOT_DIRECTORY",
+				message: `Archive action requires a directory, but ${normalizedPath} is a file`
+			}
+		};
+		const files = [];
+		await this.collectFilesForArchive(fullPath, fullPath, pattern, files);
+		const ext = format === "tar.gz" ? ".tar.gz" : ".zip";
+		const archiveName = `afs-archive-${Date.now()}${ext}`;
+		const outputPath = (0, node_path.join)((0, node_os.tmpdir)(), archiveName);
+		try {
+			if (format === "tar.gz") await this.createTarGz(fullPath, files, outputPath);
+			else await this.createZip(fullPath, files, outputPath);
+			return {
+				success: true,
+				data: {
+					outputPath,
+					size: (await (0, node_fs_promises.stat)(outputPath)).size,
+					fileCount: files.length,
+					format
+				}
+			};
+		} catch (error) {
+			try {
+				await (0, node_fs_promises.rm)(outputPath, { force: true });
+			} catch {}
+			return {
+				success: false,
+				error: {
+					code: "ARCHIVE_ERROR",
+					message: `Failed to create archive: ${error instanceof Error ? error.message : "unknown error"}`
+				}
+			};
+		}
+	}
+	async checksumAction(ctx, args) {
+		const normalizedPath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		const algorithm = args.algorithm;
+		const mountRoot = this.options.localPath;
+		const supportedAlgorithms = [
+			"md5",
+			"sha1",
+			"sha256",
+			"sha512"
+		];
+		if (!algorithm || !supportedAlgorithms.includes(algorithm)) return {
+			success: false,
+			error: {
+				code: "INVALID_ALGORITHM",
+				message: `Unsupported algorithm: ${algorithm}. Supported: ${supportedAlgorithms.join(", ")}`
+			}
+		};
+		const fullPath = (0, node_path.join)(mountRoot, normalizedPath);
+		if (!fullPath.startsWith(mountRoot)) return {
+			success: false,
+			error: {
+				code: "PATH_TRAVERSAL",
+				message: "Path traversal is not allowed"
+			}
+		};
+		let stats;
+		try {
+			stats = await (0, node_fs_promises.stat)(fullPath);
+		} catch {
+			return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Path not found: ${normalizedPath}`
+				}
+			};
+		}
+		if (stats.isDirectory()) return {
+			success: false,
+			error: {
+				code: "NOT_FILE",
+				message: `Checksum action requires a file, but ${normalizedPath} is a directory`
+			}
+		};
+		try {
+			return {
+				success: true,
+				data: {
+					hash: await new Promise((resolve, reject) => {
+						const hasher = (0, node_crypto.createHash)(algorithm);
+						const stream = (0, node_fs.createReadStream)(fullPath);
+						stream.on("data", (chunk) => hasher.update(chunk));
+						stream.on("end", () => resolve(hasher.digest("hex")));
+						stream.on("error", reject);
+					}),
+					algorithm,
+					size: stats.size,
+					path: normalizedPath
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: {
+					code: "CHECKSUM_ERROR",
+					message: `Failed to compute checksum: ${error instanceof Error ? error.message : "unknown error"}`
+				}
+			};
+		}
+	}
+	/**
+	* Recursively collect files for archiving.
+	* Excludes .afs directories and respects optional glob pattern.
+	*/
+	async collectFilesForArchive(baseDir, currentDir, pattern, files) {
+		let items;
+		try {
+			items = await (0, node_fs_promises.readdir)(currentDir);
+		} catch {
+			return;
+		}
+		for (const item of items) {
+			if (this.isHiddenAfsDir(item)) continue;
+			const fullPath = (0, node_path.join)(currentDir, item);
+			let itemStats;
+			try {
+				itemStats = await (0, node_fs_promises.stat)(fullPath);
+			} catch {
+				continue;
+			}
+			if (itemStats.isDirectory()) await this.collectFilesForArchive(baseDir, fullPath, pattern, files);
+			else {
+				const relativePath = (0, node_path.relative)(baseDir, fullPath);
+				if (pattern) {
+					if ((0, minimatch.minimatch)(relativePath, pattern, { matchBase: true })) files.push(relativePath);
+				} else files.push(relativePath);
+			}
+		}
+	}
+	/**
+	* Create a tar.gz archive from a list of files.
+	*/
+	async createTarGz(baseDir, files, outputPath) {
+		const { execSync } = await import("node:child_process");
+		if (files.length === 0) {
+			execSync(`tar czf "${outputPath}" -T /dev/null`, { cwd: baseDir });
+			return;
+		}
+		const fileListPath = (0, node_path.join)((0, node_os.tmpdir)(), `afs-tar-list-${Date.now()}.txt`);
+		await (0, node_fs_promises.writeFile)(fileListPath, files.join("\n"), "utf8");
+		try {
+			execSync(`tar czf "${outputPath}" -T "${fileListPath}"`, { cwd: baseDir });
+		} finally {
+			await (0, node_fs_promises.rm)(fileListPath, { force: true });
+		}
+	}
+	/**
+	* Create a zip archive from a list of files.
+	*/
+	async createZip(baseDir, files, outputPath) {
+		const { execSync } = await import("node:child_process");
+		if (files.length === 0) {
+			execSync(`zip -q "${outputPath}" -T 2>/dev/null || true`, { cwd: baseDir });
+			try {
+				await (0, node_fs_promises.stat)(outputPath);
+			} catch {
+				await (0, node_fs_promises.writeFile)(outputPath, Buffer.from([
+					80,
+					75,
+					5,
+					6,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0,
+					0
+				]));
+			}
+			return;
+		}
+		const fileListPath = (0, node_path.join)((0, node_os.tmpdir)(), `afs-zip-list-${Date.now()}.txt`);
+		await (0, node_fs_promises.writeFile)(fileListPath, files.join("\n"), "utf8");
+		try {
+			execSync(`cat "${fileListPath}" | zip -q "${outputPath}" -@`, { cwd: baseDir });
+		} finally {
+			await (0, node_fs_promises.rm)(fileListPath, { force: true });
+		}
+	}
+	/**
+	* Read .gitignore content safely from a directory.
+	* Returns empty string if file doesn't exist or is unreadable.
+	*/
+	async readGitignoreContent(dirPath) {
+		try {
+			return await (0, node_fs_promises.readFile)((0, node_path.join)(dirPath, ".gitignore"), "utf8");
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* Read .afsignore content safely from a directory.
+	* Returns empty string if file doesn't exist or is unreadable.
+	*/
+	async readAfsignoreContent(dirPath) {
+		try {
+			return await (0, node_fs_promises.readFile)((0, node_path.join)(dirPath, ".afsignore"), "utf8");
+		} catch {
+			return "";
+		}
+	}
+	/**
+	* Parse .afsignore content and expand @inherit directives.
+	* Returns an array of patterns with @inherit .gitignore replaced by actual gitignore rules.
+	* @param content - The .afsignore file content
+	* @param dirPath - The directory containing the .afsignore file
+	* @param mountRoot - The mount root path for security checks
+	* @param visitedPaths - Set of already visited paths to detect circular references
+	*/
+	async parseAfsignoreContent(content, dirPath, mountRoot, visitedPaths = /* @__PURE__ */ new Set()) {
+		const patterns = [];
+		const lines = content.split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (trimmed.startsWith("@inherit ")) {
+				const target = trimmed.slice(9).trim();
+				if (target === ".gitignore") {
+					const gitignoreContent = await this.readGitignoreContent(dirPath);
+					if (gitignoreContent) patterns.push(...gitignoreContent.split("\n"));
+				} else {
+					const normalizedTarget = (0, node_path.join)(dirPath, target);
+					if (!normalizedTarget.startsWith(mountRoot) || (0, node_path.isAbsolute)(target) || visitedPaths.has(normalizedTarget)) continue;
+					visitedPaths.add(normalizedTarget);
+					try {
+						const inheritedContent = await (0, node_fs_promises.readFile)(normalizedTarget, "utf8");
+						if (target.endsWith(".afsignore")) {
+							const inheritedPatterns = await this.parseAfsignoreContent(inheritedContent, (0, node_path.dirname)(normalizedTarget), mountRoot, visitedPaths);
+							patterns.push(...inheritedPatterns);
+						} else patterns.push(...inheritedContent.split("\n"));
+					} catch {}
+				}
+			} else patterns.push(line);
+		}
+		return patterns;
+	}
+	/**
+	* Add patterns to an ignore instance, handling prefixing for subdirectories.
+	* @param ig - The ignore instance to add patterns to
+	* @param patterns - Array of pattern lines
+	* @param dirPath - The directory these patterns come from
+	* @param baseDir - The base directory for relative path calculation
+	*/
+	addPatternsToIgnore(ig, patterns, dirPath, baseDir) {
+		const normalizedDirPath = dirPath.endsWith("/") ? dirPath.slice(0, -1) : dirPath;
+		const normalizedBaseDir = baseDir.endsWith("/") ? baseDir.slice(0, -1) : baseDir;
+		const needsPrefix = normalizedDirPath !== normalizedBaseDir;
+		const prefix = needsPrefix ? (0, node_path.relative)(normalizedBaseDir, normalizedDirPath) : "";
+		for (const line of patterns) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const isNegation = trimmed.startsWith("!");
+			const pattern = isNegation ? trimmed.slice(1) : trimmed;
+			if (needsPrefix) {
+				let prefixedPattern;
+				if (pattern.startsWith("/")) prefixedPattern = `/${prefix}${pattern}`;
+				else if (pattern.includes("/") && !pattern.startsWith("**/")) prefixedPattern = `${prefix}/${pattern}`;
+				else prefixedPattern = `${prefix}/**/${pattern}`;
+				ig.add(isNegation ? `!${prefixedPattern}` : prefixedPattern);
+			} else ig.add(trimmed);
+		}
+	}
+	/**
+	* Load combined ignore rules from mountRoot down to checkPath.
+	* Combines .gitignore (if useGitignore), .afsignore (if useAfsignore), and mount ignore options.
+	*
+	* Priority order (later rules override earlier):
+	* 1. Mount config `ignore` option (highest priority - always applied first as base)
+	* 2. .gitignore rules (if useGitignore=true, or via @inherit in .afsignore)
+	* 3. .afsignore rules (if useAfsignore=true)
+	*
+	* @param checkPath - The directory whose files we're checking
+	* @param mountRoot - The mounted local filesystem root
+	* @returns An object with ignore instance and the base path for matching
+	*/
+	async loadIgnoreRules(checkPath, mountRoot) {
+		const ig = (0, ignore.default)();
+		const dirsToCheck = [];
+		let currentPath = checkPath;
+		while (true) {
+			dirsToCheck.unshift(currentPath);
+			if (currentPath === mountRoot) break;
+			const parentPath = (0, node_path.dirname)(currentPath);
+			if (!currentPath.startsWith(mountRoot) || parentPath === currentPath) break;
+			currentPath = parentPath;
+		}
+		const mountIgnorePatterns = this.options.ignore || [];
+		for (const dirPath of dirsToCheck) {
+			if (this.useGitignore) {
+				const gitignoreContent = await this.readGitignoreContent(dirPath);
+				if (gitignoreContent) {
+					const gitignorePatterns = gitignoreContent.split("\n");
+					this.addPatternsToIgnore(ig, gitignorePatterns, dirPath, mountRoot);
+				}
+			}
+			if (this.useAfsignore) {
+				const afsignoreContent = await this.readAfsignoreContent(dirPath);
+				if (afsignoreContent) {
+					const afsignorePatterns = await this.parseAfsignoreContent(afsignoreContent, dirPath, mountRoot);
+					this.addPatternsToIgnore(ig, afsignorePatterns, dirPath, mountRoot);
+				}
+			}
+		}
+		const negationPatterns = [];
+		const collectNegationPatterns = (content) => {
+			for (const line of content.split("\n")) {
+				const trimmed = line.trim();
+				if (trimmed.startsWith("!") && !trimmed.startsWith("!#")) negationPatterns.push(trimmed.slice(1));
+			}
+		};
+		for (const dirPath of dirsToCheck) if (this.useAfsignore) {
+			const afsignoreContent = await this.readAfsignoreContent(dirPath);
+			if (afsignoreContent) collectNegationPatterns(afsignoreContent);
+		}
+		return {
+			ig,
+			ignoreBase: mountRoot,
+			mountIgnorePatterns,
+			negationPatterns
+		};
+	}
+	/**
+	* Check if an ignored directory might have un-ignored children based on negation patterns.
+	* This allows recursing into ignored directories when negation patterns exist for their contents.
+	*/
+	hasNegatedDescendants(relativePath, negationPatterns) {
+		const normalizedPath = relativePath.replace(/\/$/, "");
+		for (const pattern of negationPatterns) {
+			const normalizedPattern = pattern.replace(/\/$/, "");
+			if (normalizedPattern.startsWith(`${normalizedPath}/`) || normalizedPattern === normalizedPath) return true;
+			const firstSegment = normalizedPath.split("/")[0] || "";
+			if (pattern.includes("**") && firstSegment && pattern.startsWith(firstSegment)) return true;
+		}
+		return false;
+	}
+	/**
+	* Check if a path is explicitly negated by negation patterns.
+	* This is used to override the ignore library's decision for paths that match negation patterns.
+	*/
+	isNegatedByPatterns(relativePath, negationPatterns) {
+		const normalizedPath = relativePath.replace(/\/$/, "");
+		for (const pattern of negationPatterns) {
+			const normalizedPattern = pattern.replace(/\/$/, "");
+			if (normalizedPattern === normalizedPath) return true;
+			if (normalizedPattern.endsWith("/**") || normalizedPattern.endsWith("/*")) {
+				const basePath = normalizedPattern.replace(/\/\*+$/, "");
+				if (normalizedPath.startsWith(`${basePath}/`) || normalizedPath === basePath) return true;
+			}
+			if (normalizedPath.startsWith(`${normalizedPattern}/`)) return true;
+		}
+		return false;
+	}
+	/**
+	* Check if a file path should be ignored based on mount-level ignore patterns.
+	* Mount-level ignores have highest priority and cannot be overridden.
+	*/
+	isIgnoredByMountPatterns(relativePath, mountIgnorePatterns) {
+		if (mountIgnorePatterns.length === 0) return false;
+		const mountIg = (0, ignore.default)();
+		mountIg.add(mountIgnorePatterns);
+		const pathWithoutSlash = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+		return mountIg.ignores(pathWithoutSlash) || mountIg.ignores(`${pathWithoutSlash}/`);
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs.Meta)("/:path*")], AFSFS.prototype, "readMetaHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.List)("/:path*")], AFSFS.prototype, "listHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Read)("/:path*")], AFSFS.prototype, "readHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Write)("/:path*")], AFSFS.prototype, "writeHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Delete)("/:path*")], AFSFS.prototype, "deleteHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Rename)("/:path*")], AFSFS.prototype, "renameHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Search)("/:path*")], AFSFS.prototype, "searchHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Stat)("/:path*")], AFSFS.prototype, "statHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Explain)("/:path*")], AFSFS.prototype, "explainHandler", null);
+require_decorate.__decorate([(0, _aigne_afs.Read)("/.meta/.capabilities")], AFSFS.prototype, "readCapabilitiesHandler", null);
+require_decorate.__decorate([_aigne_afs.Actions.Exec("/:path*", "archive")], AFSFS.prototype, "archiveAction", null);
+require_decorate.__decorate([_aigne_afs.Actions.Exec("/:path*", "checksum")], AFSFS.prototype, "checksumAction", null);
+var src_default = AFSFS;
+
+//#endregion
+exports.AFSFS = AFSFS;
+exports.default = src_default;