@aigne/afs-fs 1.11.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,360 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_ripgrep = require('./utils/ripgrep.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
+let ignore = require("ignore");
+ignore = require_rolldown_runtime.__toESM(ignore);
+let minimatch = require("minimatch");
+let zod = require("zod");
+
+//#region src/index.ts
+const LIST_MAX_LIMIT = 1e3;
+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())),
+	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 {
+	static schema() {
+		return afsFSOptionsSchema;
+	}
+	static async load({ filepath, parsed }) {
+		return new AFSFS({
+			...await AFSFS.schema().parseAsync(parsed),
+			cwd: (0, node_path.dirname)(filepath)
+		});
+	}
+	constructor(options) {
+		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);
+		}
+		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;
+	}
+	name;
+	description;
+	accessMode;
+	agentSkills;
+	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 || "");
+	}
+	async symlinkToPhysical(path) {
+		if (await this.localPathExists) await (0, node_fs_promises.symlink)(this.options.localPath, path);
+	}
+	async list(path, options) {
+		path = (0, node_path.join)("/", 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 maxDepth = options?.maxDepth ?? 1;
+		const disableGitignore = options?.disableGitignore ?? false;
+		const pattern = options?.pattern;
+		const basePath = (0, node_path.join)(this.options.localPath, path);
+		const mountRoot = this.options.localPath;
+		if (typeof maxChildren === "number" && maxChildren <= 0) throw new Error(`Invalid maxChildren: ${maxChildren}. Must be positive.`);
+		const entries = [];
+		const queue = [];
+		queue.push({
+			fullPath: basePath,
+			relativePath: path || "/",
+			depth: 0,
+			gitignored: false
+		});
+		while (true) {
+			const item = queue.shift();
+			if (!item) break;
+			const { fullPath, relativePath, depth, gitignored } = item;
+			const stats = await (0, node_fs_promises.stat)(fullPath);
+			const isDirectory = stats.isDirectory();
+			let childItemsWithStatus;
+			if (isDirectory && !gitignored) {
+				const items = (await (0, node_fs_promises.readdir)(fullPath)).sort();
+				let ig = null;
+				let ignoreBase = mountRoot;
+				if (!disableGitignore) {
+					const result = await this.loadIgnoreRules(fullPath, mountRoot);
+					ig = result?.ig || null;
+					ignoreBase = result?.ignoreBase || mountRoot;
+				}
+				childItemsWithStatus = items.map((childName) => {
+					if (!ig) return {
+						name: childName,
+						gitignored: false
+					};
+					const itemFullPath = (0, node_path.join)(fullPath, childName);
+					const itemRelativePath = (0, node_path.relative)(ignoreBase, itemFullPath);
+					return {
+						name: childName,
+						gitignored: ig.ignores(itemRelativePath) || ig.ignores(`${itemRelativePath}/`)
+					};
+				});
+			}
+			const metadata = {
+				childrenCount: childItemsWithStatus?.length,
+				type: isDirectory ? "directory" : "file",
+				size: stats.size,
+				gitignored: gitignored || void 0
+			};
+			if (!isDirectory) metadata.mimeType = this.getMimeType(fullPath);
+			const entry = {
+				id: relativePath,
+				path: relativePath,
+				createdAt: stats.birthtime,
+				updatedAt: stats.mtime,
+				metadata
+			};
+			if (!pattern || (0, minimatch.minimatch)(relativePath, pattern, { matchBase: true })) entries.push(entry);
+			if (entries.length >= limit) {
+				if (isDirectory && entry.metadata) entry.metadata.childrenTruncated = true;
+				break;
+			}
+			if (isDirectory && depth < maxDepth && childItemsWithStatus) {
+				const itemsToProcess = childItemsWithStatus.length > maxChildren ? childItemsWithStatus.slice(0, maxChildren) : childItemsWithStatus;
+				if (itemsToProcess.length < childItemsWithStatus.length && entry.metadata) entry.metadata.childrenTruncated = true;
+				for (const child of itemsToProcess) queue.push({
+					fullPath: (0, node_path.join)(fullPath, child.name),
+					relativePath: (0, node_path.join)(relativePath, child.name),
+					depth: depth + 1,
+					gitignored: child.gitignored
+				});
+			}
+		}
+		return { data: entries };
+	}
+	async read(path, _options) {
+		try {
+			const fullPath = (0, node_path.join)(this.options.localPath, path);
+			const stats = await (0, node_fs_promises.stat)(fullPath);
+			let content;
+			const metadata = {
+				type: stats.isDirectory() ? "directory" : "file",
+				size: stats.size
+			};
+			if (stats.isFile()) {
+				const mimeType = this.getMimeType(fullPath);
+				const isBinary = this.isBinaryFile(fullPath);
+				metadata.mimeType = mimeType;
+				if (isBinary) {
+					content = (await (0, node_fs_promises.readFile)(fullPath)).toString("base64");
+					metadata.contentType = "base64";
+				} else content = await (0, node_fs_promises.readFile)(fullPath, "utf8");
+			}
+			return { data: {
+				id: path,
+				path,
+				createdAt: stats.birthtime,
+				updatedAt: stats.mtime,
+				content,
+				metadata
+			} };
+		} catch (error) {
+			return {
+				data: void 0,
+				message: error.message
+			};
+		}
+	}
+	async write(path, entry, 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"
+			});
+		}
+		const stats = await (0, node_fs_promises.stat)(fullPath);
+		return { data: {
+			id: path,
+			path,
+			createdAt: stats.birthtime,
+			updatedAt: stats.mtime,
+			content: entry.content,
+			summary: entry.summary,
+			metadata: {
+				...entry.metadata,
+				type: stats.isDirectory() ? "directory" : "file",
+				size: stats.size
+			},
+			userId: entry.userId,
+			sessionId: entry.sessionId,
+			linkTo: entry.linkTo
+		} };
+	}
+	async delete(path, options) {
+		const fullPath = (0, node_path.join)(this.options.localPath, path);
+		const recursive = options?.recursive ?? false;
+		if ((await (0, node_fs_promises.stat)(fullPath)).isDirectory() && !recursive) throw new Error(`Cannot delete directory '${path}' without recursive option. Set recursive: true to delete directories.`);
+		await (0, node_fs_promises.rm)(fullPath, {
+			recursive,
+			force: true
+		});
+		return { message: `Successfully deleted: ${path}` };
+	}
+	async rename(oldPath, newPath, options) {
+		const oldFullPath = (0, node_path.join)(this.options.localPath, oldPath);
+		const newFullPath = (0, node_path.join)(this.options.localPath, newPath);
+		const overwrite = options?.overwrite ?? false;
+		await (0, node_fs_promises.stat)(oldFullPath);
+		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 '${oldPath}' to '${newPath}'` };
+	}
+	async search(path, query, options) {
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const basePath = (0, node_path.join)(this.options.localPath, path);
+		const matches = await require_ripgrep.searchWithRipgrep(basePath, query, options);
+		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));
+			if (processedFiles.has(itemRelativePath)) continue;
+			processedFiles.add(itemRelativePath);
+			const stats = await (0, node_fs_promises.stat)(absolutePath);
+			const entry = {
+				id: itemRelativePath,
+				path: itemRelativePath,
+				createdAt: stats.birthtime,
+				updatedAt: stats.mtime,
+				summary: match.data.lines?.text,
+				metadata: {
+					type: "file",
+					size: stats.size
+				}
+			};
+			entries.push(entry);
+			if (entries.length >= limit) {
+				hasMoreFiles = true;
+				break;
+			}
+		}
+		return {
+			data: entries,
+			message: hasMoreFiles ? `Results truncated to limit ${limit}` : void 0
+		};
+	}
+	/**
+	* Load gitignore rules from mountRoot down to checkPath.
+	* Accumulates rules from parent to child for proper inheritance.
+	* Stops at .git boundaries (submodules are independent repos).
+	* @param checkPath - The directory whose files we're checking
+	* @param mountRoot - The mounted local filesystem root (stop point for walking up)
+	* @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;
+		let gitBoundary = null;
+		while (true) {
+			dirsToCheck.unshift(currentPath);
+			if (gitBoundary === null) try {
+				await (0, node_fs_promises.stat)((0, node_path.join)(currentPath, ".git"));
+				gitBoundary = currentPath;
+			} catch {}
+			if (currentPath === mountRoot) break;
+			const parentPath = (0, node_path.dirname)(currentPath);
+			if (!currentPath.startsWith(mountRoot) || parentPath === currentPath) break;
+			currentPath = parentPath;
+		}
+		const effectiveStart = gitBoundary || mountRoot;
+		const filteredDirs = dirsToCheck.filter((dir) => dir >= effectiveStart);
+		for (const dirPath of filteredDirs) try {
+			const gitignoreContent = await (0, node_fs_promises.readFile)((0, node_path.join)(dirPath, ".gitignore"), "utf8");
+			const effectiveBase = gitBoundary && dirPath >= gitBoundary ? gitBoundary : mountRoot;
+			if (dirPath !== effectiveBase) {
+				const prefix = (0, node_path.relative)(effectiveBase, dirPath);
+				const prefixedLines = gitignoreContent.split("\n").map((line) => {
+					const trimmed = line.trim();
+					if (!trimmed || trimmed.startsWith("#")) return line;
+					if (trimmed.startsWith("!")) return line;
+					if (trimmed.startsWith("/")) return `/${prefix}${trimmed}`;
+					if (trimmed.includes("/")) return `${prefix}/${trimmed}`;
+					return `${prefix}/**/${trimmed}`;
+				});
+				ig.add(prefixedLines.join("\n"));
+			} else ig.add(gitignoreContent);
+		} catch {}
+		ig.add(".git");
+		ig.add(this.options.ignore || []);
+		return {
+			ig,
+			ignoreBase: effectiveStart
+		};
+	}
+};
+
+//#endregion
+exports.AFSFS = AFSFS;

package/dist/index.d.cts

@@ -0,0 +1,98 @@
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+import { z } from "zod";
+
+//#region src/index.d.ts
+interface AFSFSOptions {
+  name?: string;
+  localPath: string;
+  description?: string;
+  ignore?: string[];
+  /**
+       * Access mode for this module.
+       * - "readonly": Only read operations are allowed
+       * - "readwrite": All operations are allowed (default, unless agentSkills is enabled)
+       * @default "readwrite" (or "readonly" when agentSkills is true)
+       */
+  accessMode?: AFSAccessMode;
+  /**
+       * Enable automatic agent skill scanning for this module.
+       * When enabled, defaults accessMode to "readonly" if not explicitly set.
+       * @default false
+       */
+  agentSkills?: boolean;
+}
+declare class AFSFS implements AFSModule {
+  options: AFSFSOptions & {
+    cwd?: string;
+  };
+  static schema(): z.ZodEffects<z.ZodObject<{
+    name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    localPath: z.ZodString;
+    description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    ignore: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
+    accessMode: z.ZodType<"readonly" | "readwrite" | undefined, z.ZodTypeDef, "readonly" | "readwrite" | undefined>;
+    agentSkills: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+  }, "strip", z.ZodTypeAny, {
+    localPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    ignore?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }, {
+    localPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    ignore?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }>, {
+    localPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    ignore?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }, any>;
+  static load({
+    filepath,
+    parsed
+  }: AFSModuleLoadParams): Promise<AFSFS>;
+  constructor(options: AFSFSOptions & {
+    cwd?: string;
+  });
+  name: string;
+  description?: string;
+  accessMode: AFSAccessMode;
+  agentSkills?: boolean;
+  private get localPathExists();
+  /**
+       * Detect MIME type based on file extension
+       */
+  private getMimeType;
+  /**
+       * Check if file is likely binary based on extension
+       */
+  private isBinaryFile;
+  symlinkToPhysical(path: string): Promise<void>;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, entry: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<{
+    message?: string;
+  }>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Load gitignore rules from mountRoot down to checkPath.
+       * Accumulates rules from parent to child for proper inheritance.
+       * Stops at .git boundaries (submodules are independent repos).
+       * @param checkPath - The directory whose files we're checking
+       * @param mountRoot - The mounted local filesystem root (stop point for walking up)
+       * @returns An object with ignore instance and the base path for matching
+       */
+  private loadIgnoreRules;
+}
+//#endregion
+export { AFSFS, AFSFSOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UA6BiB,YAAA;EAAA,IAAA;EAAA,SAAA;EAAA,WAAA;EAAA,MAAA;EAAA;AAmCjB;;;;;EAnCiB,UAAA,GAWF,aAAA;EAAA;AAwBf;;;;EAxBe,WAAA;AAAA;AAAA,cAwBF,KAAA,YAAiB,SAAA;EAAA,OAAA,EAWA,YAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GAVf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,KAAA;EAAA,YAAA,OAAA,EAM/B,YAAA;IAAA,GAAA;EAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EA2BhB,aAAA;EAAA,WAAA;EAAA,YAAA,gBAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA,kBAAA,IAAA,WAkE2B,OAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAMJ,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GA8IxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EAkDpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA6C0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAoBpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAiCiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;;;;;;EAAA,QAAA,eAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/index.d.ts
+interface AFSFSOptions {
+  name?: string;
+  localPath: string;
+  description?: string;
+  ignore?: string[];
+  /**
+       * Access mode for this module.
+       * - "readonly": Only read operations are allowed
+       * - "readwrite": All operations are allowed (default, unless agentSkills is enabled)
+       * @default "readwrite" (or "readonly" when agentSkills is true)
+       */
+  accessMode?: AFSAccessMode;
+  /**
+       * Enable automatic agent skill scanning for this module.
+       * When enabled, defaults accessMode to "readonly" if not explicitly set.
+       * @default false
+       */
+  agentSkills?: boolean;
+}
+declare class AFSFS implements AFSModule {
+  options: AFSFSOptions & {
+    cwd?: string;
+  };
+  static schema(): z.ZodEffects<z.ZodObject<{
+    name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    localPath: z.ZodString;
+    description: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;
+    ignore: z.ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
+    accessMode: z.ZodType<"readonly" | "readwrite" | undefined, z.ZodTypeDef, "readonly" | "readwrite" | undefined>;
+    agentSkills: z.ZodType<boolean | undefined, z.ZodTypeDef, boolean | undefined>;
+  }, "strip", z.ZodTypeAny, {
+    localPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    ignore?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }, {
+    localPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    ignore?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }>, {
+    localPath: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    ignore?: string[] | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    agentSkills?: boolean | undefined;
+  }, any>;
+  static load({
+    filepath,
+    parsed
+  }: AFSModuleLoadParams): Promise<AFSFS>;
+  constructor(options: AFSFSOptions & {
+    cwd?: string;
+  });
+  name: string;
+  description?: string;
+  accessMode: AFSAccessMode;
+  agentSkills?: boolean;
+  private get localPathExists();
+  /**
+       * Detect MIME type based on file extension
+       */
+  private getMimeType;
+  /**
+       * Check if file is likely binary based on extension
+       */
+  private isBinaryFile;
+  symlinkToPhysical(path: string): Promise<void>;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, entry: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<{
+    message?: string;
+  }>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Load gitignore rules from mountRoot down to checkPath.
+       * Accumulates rules from parent to child for proper inheritance.
+       * Stops at .git boundaries (submodules are independent repos).
+       * @param checkPath - The directory whose files we're checking
+       * @param mountRoot - The mounted local filesystem root (stop point for walking up)
+       * @returns An object with ignore instance and the base path for matching
+       */
+  private loadIgnoreRules;
+}
+//#endregion
+export { AFSFS, AFSFSOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;UA6BiB,YAAA;EAAA,IAAA;EAAA,SAAA;EAAA,WAAA;EAAA,MAAA;EAAA;AAmCjB;;;;;EAnCiB,UAAA,GAWF,aAAA;EAAA;AAwBf;;;;EAxBe,WAAA;AAAA;AAAA,cAwBF,KAAA,YAAiB,SAAA;EAAA,OAAA,EAWA,YAAA;IAAA,GAAA;EAAA;EAAA,OAAA,OAAA,GAVf,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI2B,mBAAA,GAAmB,OAAA,CAAA,KAAA;EAAA,YAAA,OAAA,EAM/B,YAAA;IAAA,GAAA;EAAA;EAAA,IAAA;EAAA,WAAA;EAAA,UAAA,EA2BhB,aAAA;EAAA,WAAA;EAAA,YAAA,gBAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,YAAA;EAAA,kBAAA,IAAA,WAkE2B,OAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAMJ,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,QAAA,GA8IxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,KAAA,EAkDpD,oBAAA,EAAA,OAAA,GACG,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GA6C0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAoBpD,gBAAA,GACT,OAAA;IAAA,OAAA;EAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAiCiD,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;;;;;;EAAA,QAAA,eAAA;AAAA"}