@aigne/afs 1.11.0-beta → 1.11.0-beta.10

package/dist/index.cjs

@@ -1,346 +1,73 @@
-let _aigne_uuid = require("@aigne/uuid");
-let strict_event_emitter = require("strict-event-emitter");
-let ufo = require("ufo");
-let zod = require("zod");
+const require_error = require('./error.cjs');
+const require_path = require('./path.cjs');
+const require_afs = require('./afs.cjs');
+const require_world_mapping = require('./capabilities/world-mapping.cjs');
+const require_validation = require('./meta/validation.cjs');
+const require_well_known_kinds = require('./meta/well-known-kinds.cjs');
+const require_kind = require('./meta/kind.cjs');
+const require_path$1 = require('./meta/path.cjs');
+require('./meta/index.cjs');
+const require_decorators = require('./provider/decorators.cjs');
+const require_router = require('./provider/router.cjs');
+const require_base = require('./provider/base.cjs');
+require('./provider/index.cjs');
+const require_registry = require('./registry.cjs');
+const require_type = require('./type.cjs');
 
-//#region src/error.ts
-/**
-* Base error class for all AFS errors.
-*/
-var AFSError = class extends Error {
-	code;
-	constructor(message, code) {
-		super(message);
-		this.name = "AFSError";
-		this.code = code;
-	}
-};
-/**
-* Error thrown when attempting write operations on a readonly AFS or module.
-*/
-var AFSReadonlyError = class extends AFSError {
-	constructor(message) {
-		super(message, "AFS_READONLY");
-		this.name = "AFSReadonlyError";
-	}
-};
-
-//#endregion
-//#region src/type.ts
-/**
-* Zod schema for access mode validation.
-* Can be reused across modules that support access mode configuration.
-*/
-const accessModeSchema = zod.z.enum(["readonly", "readwrite"]).describe("Access mode for this module").optional();
-const afsEntrySchema = zod.z.object({
-	id: zod.z.string(),
-	createdAt: zod.z.date().optional(),
-	updatedAt: zod.z.date().optional(),
-	path: zod.z.string(),
-	userId: zod.z.string().nullable().optional(),
-	sessionId: zod.z.string().nullable().optional(),
-	summary: zod.z.string().nullable().optional(),
-	description: zod.z.string().nullable().optional(),
-	metadata: zod.z.record(zod.z.any()).nullable().optional(),
-	linkTo: zod.z.string().nullable().optional(),
-	content: zod.z.any().optional()
-});
-
-//#endregion
-//#region src/afs.ts
-const DEFAULT_MAX_DEPTH = 1;
-const MODULES_ROOT_DIR = "/modules";
-var AFS = class extends strict_event_emitter.Emitter {
-	name = "AFSRoot";
-	constructor(options = {}) {
-		super();
-		this.options = options;
-		for (const module of options?.modules ?? []) this.mount(module);
-	}
-	modules = /* @__PURE__ */ new Map();
-	/**
-	* Check if write operations are allowed for the given module.
-	* Throws AFSReadonlyError if not allowed.
-	*/
-	checkWritePermission(module, operation, path) {
-		if (module.accessMode !== "readwrite") throw new AFSReadonlyError(`Module '${module.name}' is readonly, cannot perform ${operation} to ${path}`);
-	}
-	mount(module) {
-		if (module.name.includes("/")) throw new Error(`Invalid module name: ${module.name}. Module name must not contain '/'`);
-		const path = (0, ufo.joinURL)(MODULES_ROOT_DIR, module.name);
-		if (this.modules.has(path)) throw new Error(`Module already mounted at path: ${path}`);
-		this.modules.set(path, module);
-		module.onMount?.(this);
-		return this;
-	}
-	async listModules() {
-		return Array.from(this.modules.entries()).map(([path, module]) => ({
-			path,
-			name: module.name,
-			description: module.description,
-			module
-		}));
-	}
-	async list(path, options = {}) {
-		let preset;
-		if (options.preset) {
-			preset = this.options?.context?.list?.presets?.[options.preset];
-			if (!preset) throw new Error(`Preset not found: ${options.preset}`);
-		}
-		return await this.processWithPreset(path, void 0, preset, {
-			...options,
-			defaultSelect: () => this._list(path, options)
-		});
-	}
-	async _list(path, options = {}) {
-		const results = [];
-		if (path === "/" && this.modules.size > 0) {
-			const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-			results.push({
-				id: "modules",
-				path: MODULES_ROOT_DIR,
-				summary: "All mounted modules"
-			});
-			if (maxDepth === 1) return { data: results };
-			const childrenResult = await this._list(MODULES_ROOT_DIR, {
-				...options,
-				maxDepth: maxDepth - 1
-			});
-			results.push(...childrenResult.data);
-			return { data: results };
-		}
-		const matches = this.findModules(path, options);
-		for (const matched of matches) {
-			if (matched.maxDepth === 0) {
-				const moduleEntry = {
-					id: matched.module.name,
-					path: matched.modulePath,
-					summary: matched.module.description
-				};
-				results.push(moduleEntry);
-				continue;
-			}
-			if (!matched.module.list) continue;
-			try {
-				const { data } = await matched.module.list(matched.subpath, {
-					...options,
-					maxDepth: matched.maxDepth
-				});
-				const children = data.map((entry) => ({
-					...entry,
-					path: (0, ufo.joinURL)(matched.modulePath, entry.path)
-				}));
-				results.push(...children);
-			} catch (error) {
-				throw new Error(`Error listing from module at ${matched.modulePath}: ${error.message}`);
-			}
-		}
-		return { data: results };
-	}
-	async read(path, _options) {
-		const modules = this.findModules(path, { exactMatch: true });
-		for (const { module, modulePath, subpath } of modules) {
-			const res = await module.read?.(subpath);
-			if (res?.data) return {
-				...res,
-				data: {
-					...res.data,
-					path: (0, ufo.joinURL)(modulePath, res.data.path)
-				}
-			};
-		}
-		return {
-			data: void 0,
-			message: "File not found"
-		};
-	}
-	async write(path, content, options) {
-		const module = this.findModules(path, { exactMatch: true })[0];
-		if (!module?.module.write) throw new Error(`No module found for path: ${path}`);
-		this.checkWritePermission(module.module, "write", path);
-		const res = await module.module.write(module.subpath, content, options);
-		return {
-			...res,
-			data: {
-				...res.data,
-				path: (0, ufo.joinURL)(module.modulePath, res.data.path)
-			}
-		};
-	}
-	async delete(path, options) {
-		const module = this.findModules(path, { exactMatch: true })[0];
-		if (!module?.module.delete) throw new Error(`No module found for path: ${path}`);
-		this.checkWritePermission(module.module, "delete", path);
-		return await module.module.delete(module.subpath, options);
-	}
-	async rename(oldPath, newPath, options) {
-		const oldModule = this.findModules(oldPath, { exactMatch: true })[0];
-		const newModule = this.findModules(newPath, { exactMatch: true })[0];
-		if (!oldModule || !newModule || oldModule.modulePath !== newModule.modulePath) throw new Error(`Cannot rename across different modules. Both paths must be in the same module.`);
-		if (!oldModule.module.rename) throw new Error(`Module does not support rename operation: ${oldModule.modulePath}`);
-		this.checkWritePermission(oldModule.module, "rename", oldPath);
-		return await oldModule.module.rename(oldModule.subpath, newModule.subpath, options);
-	}
-	async search(path, query, options = {}) {
-		let preset;
-		if (options.preset) {
-			preset = this.options?.context?.search?.presets?.[options.preset];
-			if (!preset) throw new Error(`Preset not found: ${options.preset}`);
-		}
-		return await this.processWithPreset(path, query, preset, {
-			...options,
-			defaultSelect: () => this._search(path, query, options)
-		});
-	}
-	async processWithPreset(path, query, preset, options) {
-		const select = options.select || preset?.select;
-		const per = options.per || preset?.per;
-		const dedupe = options.dedupe || preset?.dedupe;
-		const format = options.format || preset?.format;
-		const entries = select ? (await this._select(path, query, select, options)).data : (await options.defaultSelect()).data;
-		const mapped = per ? await Promise.all(entries.map((data) => per.invoke({ data }, options).then((res) => res.data))) : entries;
-		const deduped = dedupe ? await dedupe.invoke({ data: mapped }, options).then((res) => res.data) : mapped;
-		let formatted = deduped;
-		if (format === "simple-list" || format === "tree") {
-			const valid = zod.z.array(afsEntrySchema).safeParse(deduped);
-			if (!valid.data) throw new Error("Tree format requires entries to be AFSEntry objects");
-			if (format === "tree") formatted = this.buildTreeView(valid.data);
-			else if (format === "simple-list") formatted = this.buildSimpleListView(valid.data);
-		} else if (typeof format === "object" && typeof format.invoke === "function") formatted = await format.invoke({ data: deduped }, options).then((res) => res.data);
-		return { data: formatted };
-	}
-	async _select(path, query, select, options) {
-		const { data } = await select.invoke({
-			path,
-			query
-		}, options);
-		return { data: (await Promise.all(data.map((p) => this.read(p).then((res) => res.data)))).filter((i) => !!i) };
-	}
-	async _search(path, query, options) {
-		const results = [];
-		const messages = [];
-		for (const { module, modulePath, subpath } of this.findModules(path)) {
-			if (!module.search) continue;
-			try {
-				const { data, message } = await module.search(subpath, query, options);
-				results.push(...data.map((entry) => ({
-					...entry,
-					path: (0, ufo.joinURL)(modulePath, entry.path)
-				})));
-				if (message) messages.push(message);
-			} catch (error) {
-				throw new Error(`Error searching in module at ${modulePath}: ${error.message}`);
-			}
-		}
-		return {
-			data: results,
-			message: messages.join("; ")
-		};
-	}
-	findModules(path, options) {
-		const maxDepth = Math.max(options?.maxDepth ?? DEFAULT_MAX_DEPTH, 1);
-		const matched = [];
-		for (const [modulePath, module] of this.modules) {
-			const pathSegments = path.split("/").filter(Boolean);
-			const modulePathSegments = modulePath.split("/").filter(Boolean);
-			let newMaxDepth;
-			let subpath;
-			let remainedModulePath;
-			if (!options?.exactMatch && modulePath.startsWith(path)) {
-				newMaxDepth = Math.max(0, maxDepth - (modulePathSegments.length - pathSegments.length));
-				subpath = "/";
-				remainedModulePath = (0, ufo.joinURL)("/", ...modulePathSegments.slice(pathSegments.length).slice(0, maxDepth));
-			} else if (path.startsWith(modulePath)) {
-				newMaxDepth = maxDepth;
-				subpath = (0, ufo.joinURL)("/", ...pathSegments.slice(modulePathSegments.length));
-				remainedModulePath = "/";
-			} else continue;
-			if (newMaxDepth < 0) continue;
-			matched.push({
-				module,
-				modulePath,
-				maxDepth: newMaxDepth,
-				subpath,
-				remainedModulePath
-			});
-		}
-		return matched;
-	}
-	async exec(path, args, options) {
-		const module = this.findModules(path)[0];
-		if (!module?.module.exec) throw new Error(`No module found for path: ${path}`);
-		return await module.module.exec(module.subpath, args, options);
-	}
-	buildSimpleListView(entries) {
-		return entries.map((entry) => `${entry.path}${this.buildMetadataSuffix(entry)}`);
-	}
-	buildTreeView(entries) {
-		const tree = {};
-		const entryMap = /* @__PURE__ */ new Map();
-		for (const entry of entries) {
-			entryMap.set(entry.path, entry);
-			const parts = entry.path.split("/").filter(Boolean);
-			let current = tree;
-			for (const part of parts) {
-				if (!current[part]) current[part] = {};
-				current = current[part];
-			}
-		}
-		const renderTree = (node, prefix = "", currentPath = "") => {
-			let result = "";
-			const keys = Object.keys(node);
-			keys.forEach((key, index) => {
-				const isLast = index === keys.length - 1;
-				const fullPath = currentPath ? `${currentPath}/${key}` : `/${key}`;
-				const entry = entryMap.get(fullPath);
-				result += `${prefix}${isLast ? "└── " : "├── "}${key}${entry ? this.buildMetadataSuffix(entry) : ""}`;
-				result += `\n`;
-				result += renderTree(node[key], `${prefix}${isLast ? "    " : "│   "}`, fullPath);
-			});
-			return result;
-		};
-		return renderTree(tree);
-	}
-	buildMetadataSuffix(entry) {
-		const metadataParts = [];
-		const childrenCount = entry?.metadata?.childrenCount;
-		if (typeof childrenCount === "number") metadataParts.push(`${childrenCount} items`);
-		if (entry?.metadata?.childrenTruncated) metadataParts.push("truncated");
-		if (entry?.metadata?.gitignored) metadataParts.push("gitignored");
-		if (entry?.metadata?.execute) metadataParts.push("executable");
-		return metadataParts.length > 0 ? ` [${metadataParts.join(", ")}]` : "";
-	}
-	physicalPath;
-	async initializePhysicalPath() {
-		this.physicalPath ??= (async () => {
-			const path = await import("node:path");
-			const os = await import("node:os");
-			const fs = await import("node:fs/promises");
-			const rootDir = path.join(os.tmpdir(), (0, _aigne_uuid.v7)());
-			await fs.mkdir(rootDir, { recursive: true });
-			for (const [modulePath, module] of this.modules) {
-				const physicalModulePath = path.join(rootDir, modulePath);
-				await fs.mkdir(path.dirname(physicalModulePath), { recursive: true });
-				await module.symlinkToPhysical?.(physicalModulePath);
-			}
-			return rootDir;
-		})();
-		return this.physicalPath;
-	}
-	async cleanupPhysicalPath() {
-		if (this.physicalPath) {
-			await (await import("node:fs/promises")).rm(await this.physicalPath, {
-				recursive: true,
-				force: true
-			});
-			this.physicalPath = void 0;
-		}
-	}
-};
-
-//#endregion
-exports.AFS = AFS;
-exports.AFSError = AFSError;
-exports.AFSReadonlyError = AFSReadonlyError;
-exports.accessModeSchema = accessModeSchema;
-exports.afsEntrySchema = afsEntrySchema;
+exports.AFS = require_afs.AFS;
+exports.AFSBaseProvider = require_base.AFSBaseProvider;
+exports.AFSError = require_error.AFSError;
+exports.AFSMountError = require_error.AFSMountError;
+exports.AFSNotFoundError = require_error.AFSNotFoundError;
+exports.AFSPathError = require_path.AFSPathError;
+exports.AFSReadonlyError = require_error.AFSReadonlyError;
+exports.AFSValidationError = require_error.AFSValidationError;
+exports.Actions = require_decorators.Actions;
+exports.Delete = require_decorators.Delete;
+exports.Exec = require_decorators.Exec;
+exports.Explain = require_decorators.Explain;
+exports.KINDS_SEGMENT = require_path$1.KINDS_SEGMENT;
+exports.KindError = require_kind.KindError;
+exports.List = require_decorators.List;
+exports.META_SEGMENT = require_path$1.META_SEGMENT;
+exports.Meta = require_decorators.Meta;
+exports.ProviderRegistry = require_registry.ProviderRegistry;
+exports.ProviderRouter = require_router.ProviderRouter;
+exports.Read = require_decorators.Read;
+exports.Rename = require_decorators.Rename;
+exports.Search = require_decorators.Search;
+exports.Stat = require_decorators.Stat;
+exports.WELL_KNOWN_KINDS = require_well_known_kinds.WELL_KNOWN_KINDS;
+exports.WELL_KNOWN_KINDS_MAP = require_well_known_kinds.WELL_KNOWN_KINDS_MAP;
+exports.Write = require_decorators.Write;
+exports.accessModeSchema = require_type.accessModeSchema;
+exports.actionSummarySchema = require_type.actionSummarySchema;
+exports.afsDocument = require_well_known_kinds.afsDocument;
+exports.afsEntrySchema = require_type.afsEntrySchema;
+exports.afsExecutable = require_well_known_kinds.afsExecutable;
+exports.afsImage = require_well_known_kinds.afsImage;
+exports.afsLink = require_well_known_kinds.afsLink;
+exports.afsNode = require_well_known_kinds.afsNode;
+exports.clearRoutes = require_decorators.clearRoutes;
+exports.combineValidationResults = require_validation.combineValidationResults;
+exports.commonMetaSchema = require_well_known_kinds.commonMetaSchema;
+exports.createKindResolver = require_kind.createKindResolver;
+exports.defaultKindResolver = require_kind.defaultKindResolver;
+exports.defineKind = require_kind.defineKind;
+exports.getInheritanceChain = require_kind.getInheritanceChain;
+exports.getNodePathFromMetaPath = require_path$1.getNodePathFromMetaPath;
+exports.getRoutes = require_decorators.getRoutes;
+exports.getWellKnownKind = require_well_known_kinds.getWellKnownKind;
+exports.isCanonicalPath = require_path.isCanonicalPath;
+exports.isKindsPath = require_path$1.isKindsPath;
+exports.isMetaPath = require_path$1.isMetaPath;
+exports.isWellKnownKind = require_well_known_kinds.isWellKnownKind;
+exports.isWorldMappingCapable = require_world_mapping.isWorldMappingCapable;
+exports.normalizePath = require_path.normalizePath;
+exports.parseCanonicalPath = require_path.parseCanonicalPath;
+exports.parseMetaPath = require_path$1.parseMetaPath;
+exports.resolveKindSchema = require_kind.resolveKindSchema;
+exports.toCanonicalPath = require_path.toCanonicalPath;
+exports.validateModuleName = require_path.validateModuleName;
+exports.validateNodes = require_validation.validateNodes;
+exports.validatePath = require_path.validatePath;