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

package/dist/repl.cjs

@@ -0,0 +1,491 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_cli_auth_context = require('./credential/cli-auth-context.cjs');
+const require_store = require('./credential/store.cjs');
+const require_afs_loader = require('./config/afs-loader.cjs');
+const require_index = require('./core/executor/index.cjs');
+let node_path = require("node:path");
+let node_readline = require("node:readline");
+let ufo = require("ufo");
+
+//#region src/repl.ts
+/**
+* AFS CLI Interactive REPL
+*
+* Single-file REPL implementation for `afs -i` / `afs --interactive`.
+* Provides: REPL loop, cd/pwd, Tab completion, explore TUI integration.
+*/
+/** Commands that default to current path when no path argument is given in REPL */
+const DEFAULT_PATH_COMMANDS = new Set([
+	"ls",
+	"read",
+	"stat",
+	"explain",
+	"explore"
+]);
+const ALL_COMMANDS = [
+	"ls",
+	"read",
+	"write",
+	"delete",
+	"stat",
+	"exec",
+	"explain",
+	"mount",
+	"explore",
+	"cd",
+	"pwd",
+	"help",
+	"exit"
+];
+function createReplContext(options) {
+	return {
+		executor: options.executor,
+		afs: options.afs,
+		version: options.version,
+		currentPath: "/",
+		currentNamespace: null,
+		completionCache: /* @__PURE__ */ new Map()
+	};
+}
+function getPrompt(ctx) {
+	const dirname = ctx.currentPath === "/" ? "/" : (0, node_path.basename)(ctx.currentPath);
+	return `afs ${ctx.currentNamespace ? `${ctx.currentNamespace}:` : ""}${dirname}> `;
+}
+function getBanner(ctx) {
+	const mountCount = ctx.afs.getMounts().length;
+	const plural = mountCount === 1 ? "provider" : "providers";
+	return `AFS Interactive Shell v${ctx.version} — ${mountCount} ${plural} mounted. Type "help" for commands.`;
+}
+async function handleBuiltinCommand(input, ctx) {
+	const trimmed = input.trim();
+	if (!trimmed) return null;
+	const parts = trimmed.split(/\s+/);
+	switch (parts[0]) {
+		case "exit":
+		case "quit": return {
+			exit: true,
+			output: "Bye!"
+		};
+		case "help": return { output: formatHelp() };
+		case "pwd": return handlePwd(ctx);
+		case "cd": return handleCd(parts.slice(1).join(" "), ctx);
+		default: return null;
+	}
+}
+function formatHelp() {
+	return [
+		"Available commands:",
+		"",
+		"  AFS Commands:",
+		"    ls [path]               List directory contents (default: current dir)",
+		"    read [path]             Read file content (default: current node)",
+		"    write <path> [content]  Write content to file",
+		"    delete <path>           Delete file or directory",
+		"    stat [path]             Get file or directory info (default: current node)",
+		"    exec <action>           Execute an action",
+		"    explain [topic]         Explain AFS concepts or paths (default: current path)",
+		"    mount                   Mount management",
+		"    explore [path]          Interactive TUI explorer (default: current dir)",
+		"",
+		"  REPL Commands:",
+		"    cd [path]               Change working directory",
+		"    pwd                     Print working directory",
+		"    help                    Show this help",
+		"    exit / quit             Exit REPL",
+		"",
+		"  Tips:",
+		"    - Commands work with or without 'afs' prefix",
+		"    - Use Tab for command and path completion",
+		"    - Ctrl+D to exit"
+	].join("\n");
+}
+function handlePwd(ctx) {
+	if (ctx.currentNamespace) return { output: `@${ctx.currentNamespace}${ctx.currentPath}` };
+	return { output: ctx.currentPath };
+}
+async function handleCd(target, ctx) {
+	if (!target || target.trim() === "") {
+		ctx.currentPath = "/";
+		return {};
+	}
+	const trimmed = target.trim();
+	if (trimmed === "@default") {
+		ctx.currentNamespace = null;
+		ctx.currentPath = "/";
+		return {};
+	}
+	if (trimmed.startsWith("@")) {
+		const rest = trimmed.slice(1);
+		const slashIdx = rest.indexOf("/");
+		if (slashIdx === -1) {
+			const ns$1 = rest;
+			if (!ns$1) return { output: "cd: invalid namespace" };
+			try {
+				const canonicalPath = `$afs:${ns$1}/`;
+				await ctx.afs.stat(canonicalPath);
+				ctx.currentNamespace = ns$1;
+				ctx.currentPath = "/";
+				return {};
+			} catch {
+				return { output: `cd: no such path: @${ns$1}/` };
+			}
+		}
+		const ns = rest.slice(0, slashIdx);
+		const path = rest.slice(slashIdx) || "/";
+		if (!ns) return { output: "cd: invalid namespace" };
+		try {
+			const canonicalPath = `$afs:${ns}${path}`;
+			await ctx.afs.stat(canonicalPath);
+			ctx.currentNamespace = ns;
+			ctx.currentPath = path;
+			return {};
+		} catch {
+			return { output: `cd: no such path: @${ns}${path}` };
+		}
+	}
+	if (trimmed.startsWith("/")) {
+		const resolved$1 = normalizePath(trimmed);
+		try {
+			const canonicalPath = ctx.currentNamespace ? `$afs:${ctx.currentNamespace}${resolved$1}` : resolved$1;
+			await ctx.afs.stat(canonicalPath);
+			ctx.currentPath = resolved$1;
+			return {};
+		} catch {
+			return { output: `cd: no such path: ${trimmed}` };
+		}
+	}
+	const resolved = normalizePath((0, ufo.joinURL)(ctx.currentPath, trimmed));
+	try {
+		const canonicalPath = ctx.currentNamespace ? `$afs:${ctx.currentNamespace}${resolved}` : resolved;
+		await ctx.afs.stat(canonicalPath);
+		ctx.currentPath = resolved;
+		return {};
+	} catch {
+		return { output: `cd: no such path: ${trimmed}` };
+	}
+}
+function normalizePath(path) {
+	const parts = path.split("/").filter(Boolean);
+	const resolved = [];
+	for (const part of parts) if (part === "..") resolved.pop();
+	else if (part !== ".") resolved.push(part);
+	return `/${resolved.join("/")}`;
+}
+function resolveArgvPath(input, ctx) {
+	const tokens = tokenize(input);
+	if (tokens.length === 0) return tokens;
+	let cmdIdx = 0;
+	if (tokens[0] === "afs" && tokens.length > 1) cmdIdx = 1;
+	const cmd = tokens[cmdIdx];
+	if (!cmd) return tokens;
+	let argIdx = -1;
+	for (let i = cmdIdx + 1; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (!token.startsWith("-")) {
+			if (cmd === "mount" && (token === "list" || token === "ls" || token === "add" || token === "remove")) continue;
+			argIdx = i;
+			break;
+		}
+		if (token.startsWith("--") && !token.includes("=") && i + 1 < tokens.length) i++;
+	}
+	if (argIdx === -1) {
+		if (DEFAULT_PATH_COMMANDS.has(cmd)) {
+			const currentFullPath = ctx.currentNamespace ? `@${ctx.currentNamespace}${ctx.currentPath}` : ctx.currentPath;
+			tokens.push(currentFullPath);
+		}
+		return tokens;
+	}
+	const arg = tokens[argIdx];
+	if (arg.startsWith("/") || arg.startsWith("@") || arg.startsWith("$afs")) return tokens;
+	const resolved = normalizePath((0, ufo.joinURL)(ctx.currentPath, arg));
+	tokens[argIdx] = ctx.currentNamespace ? `@${ctx.currentNamespace}${resolved}` : resolved;
+	return tokens;
+}
+function tokenize(input) {
+	const tokens = [];
+	let current = "";
+	let inQuote = false;
+	let quoteChar = "";
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		if (inQuote) if (char === quoteChar) inQuote = false;
+		else current += char;
+		else if (char === "\"" || char === "'") {
+			inQuote = true;
+			quoteChar = char;
+		} else if (char === " " || char === "	") {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+		} else current += char;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+}
+function isExploreCommand(cmd) {
+	const normalized = cmd.replace(/^afs\s+/, "").trim();
+	return normalized === "explore" || normalized.startsWith("explore ");
+}
+function parseExplorePath(cmd, ctx) {
+	const path = cmd.replace(/^afs\s+/, "").trim().split(/\s+/)[1];
+	if (!path) {
+		if (ctx.currentNamespace) return `$afs:${ctx.currentNamespace}${ctx.currentPath}`;
+		return ctx.currentPath;
+	}
+	if (!path.startsWith("/") && !path.startsWith("@") && !path.startsWith("$afs")) {
+		const resolved = normalizePath((0, ufo.joinURL)(ctx.currentPath, path));
+		if (ctx.currentNamespace) return `$afs:${ctx.currentNamespace}${resolved}`;
+		return resolved;
+	}
+	return path;
+}
+function createCompleter(ctx) {
+	return function completer(line, callback) {
+		const tokens = line.trimStart().split(/\s+/);
+		if (tokens.length <= 1) {
+			const partial = tokens[0] || "";
+			callback(null, [ALL_COMMANDS.filter((c) => c.startsWith(partial)), partial]);
+			return;
+		}
+		const lastToken = tokens[tokens.length - 1];
+		if (lastToken.startsWith("-")) {
+			callback(null, [[], lastToken]);
+			return;
+		}
+		let parentDir;
+		let prefix;
+		if (lastToken.includes("/")) {
+			const lastSlash = lastToken.lastIndexOf("/");
+			const parentPart = lastToken.slice(0, lastSlash + 1) || "/";
+			prefix = lastToken.slice(lastSlash + 1);
+			if (parentPart.startsWith("/") || parentPart.startsWith("@") || parentPart.startsWith("$afs")) parentDir = parentPart;
+			else parentDir = (0, ufo.joinURL)(ctx.currentPath, parentPart);
+		} else {
+			parentDir = ctx.currentPath;
+			prefix = lastToken;
+		}
+		const queryPath = ctx.currentNamespace && !parentDir.startsWith("@") && !parentDir.startsWith("$afs") ? `$afs:${ctx.currentNamespace}${parentDir}` : parentDir;
+		const cacheKey = queryPath;
+		const cached = ctx.completionCache.get(cacheKey);
+		if (cached) {
+			callback(null, [buildCompletions(cached, prefix, lastToken), lastToken]);
+			return;
+		}
+		ctx.afs.list(queryPath).then((result) => {
+			const entries = result.data || [];
+			ctx.completionCache.set(cacheKey, entries);
+			callback(null, [buildCompletions(entries, prefix, lastToken), lastToken]);
+		}).catch(() => {
+			callback(null, [[], lastToken]);
+		});
+	};
+}
+function buildCompletions(entries, prefix, lastToken) {
+	return entries.filter((e) => {
+		return (0, node_path.basename)(e.path).startsWith(prefix);
+	}).map((e) => {
+		const name = (0, node_path.basename)(e.path);
+		const suffix = typeof e.meta?.childrenCount === "number" ? "/" : " ";
+		if (lastToken.includes("/")) {
+			const lastSlash = lastToken.lastIndexOf("/");
+			return lastToken.slice(0, lastSlash + 1) + name + suffix;
+		}
+		return name + suffix;
+	});
+}
+function cleanupStdinAfterBlessed() {
+	const stdin = process.stdin;
+	stdin.removeAllListeners("keypress");
+	stdin.removeAllListeners("data");
+	delete stdin._blessedInput;
+	delete stdin._keypressHandler;
+	delete stdin._dataHandler;
+	delete stdin._keypressDecoder;
+	delete stdin._kpiListener;
+	if (stdin.setRawMode) stdin.setRawMode(false);
+	if (stdin._readableState) {
+		stdin._readableState.flowing = null;
+		stdin._readableState.reading = false;
+	}
+}
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const SPINNER_INTERVAL_MS = 80;
+function createSpinner() {
+	let frameIdx = 0;
+	let text = "";
+	let timer = null;
+	return {
+		start(initialText) {
+			text = initialText;
+			timer = setInterval(() => {
+				const frame = SPINNER_FRAMES[frameIdx % SPINNER_FRAMES.length];
+				process.stderr.write(`\r${frame} ${text}`);
+				frameIdx++;
+			}, SPINNER_INTERVAL_MS);
+		},
+		update(newText) {
+			text = newText;
+		},
+		stop() {
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+			process.stderr.write("\r\x1B[K");
+		}
+	};
+}
+async function startRepl(options) {
+	const { cwd, version, onExit, extraProviders } = options;
+	const spinner = createSpinner();
+	spinner.start("Mounting providers...");
+	let failures = [];
+	const { afs, failures: mountFailures } = await require_afs_loader.loadAFS(cwd, {
+		authContext: require_cli_auth_context.createCLIAuthContext(),
+		credentialStore: require_store.createCredentialStore(),
+		onProgress({ total, completed, failed }) {
+			spinner.update(`Mounting providers... (${completed}/${total}${failed > 0 ? `, ${failed} failed` : ""})`);
+		}
+	});
+	failures = mountFailures;
+	if (extraProviders) for (const { provider, mountPath } of extraProviders) try {
+		await afs.mount(provider, mountPath);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		failures.push({
+			path: mountPath,
+			reason: msg
+		});
+	}
+	spinner.stop();
+	if (failures.length > 0) {
+		const noun = failures.length === 1 ? "mount" : "mounts";
+		console.warn(`⚠ ${failures.length} ${noun} failed:`);
+		for (const f of failures) console.warn(`  - ${f.path}: ${f.reason}`);
+	}
+	const executor = new require_index.AFSCommandExecutor(afs, {
+		cwd,
+		tty: true,
+		version
+	});
+	const ctx = createReplContext({
+		executor,
+		afs,
+		version
+	});
+	console.log(getBanner(ctx));
+	let closed = false;
+	let rl;
+	let originalDataHandler = null;
+	function startReplLoop() {
+		const stdin = process.stdin;
+		if (stdin._readableState) {
+			stdin._readableState.flowing = null;
+			stdin._readableState.reading = false;
+		}
+		rl = (0, node_readline.createInterface)({
+			input: process.stdin,
+			output: process.stdout,
+			prompt: getPrompt(ctx),
+			historySize: 100,
+			completer: createCompleter(ctx)
+		});
+		if (!originalDataHandler && stdin.listenerCount("data") > 0) originalDataHandler = stdin.listeners("data")[0] ?? null;
+		if (stdin.listenerCount("data") === 0 && originalDataHandler) {
+			stdin.on("data", originalDataHandler);
+			stdin.resume();
+		}
+		rl.on("line", async (line) => {
+			const trimmed = line.trim();
+			if (!trimmed) {
+				if (!closed) rl.prompt();
+				return;
+			}
+			if (isExploreCommand(trimmed)) {
+				await handleExplore(trimmed, ctx);
+				return;
+			}
+			const builtinResult = await handleBuiltinCommand(trimmed, ctx);
+			if (builtinResult) {
+				if (builtinResult.output) console.log(builtinResult.output);
+				if (builtinResult.exit) {
+					closed = true;
+					rl.close();
+					return;
+				}
+				if (!closed) {
+					rl.setPrompt(getPrompt(ctx));
+					rl.prompt();
+				}
+				return;
+			}
+			const resolved = resolveArgvPath(trimmed, ctx);
+			try {
+				const result = await executor.execute(resolved);
+				if (result.formatted) console.log(result.formatted);
+				if (!result.success && result.error) {
+					if (!result.formatted.includes(result.error.message)) console.error(result.error.message);
+				}
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				console.error(`Error: ${msg}`);
+			}
+			ctx.completionCache.clear();
+			if (!closed) rl.prompt();
+		});
+		rl.on("close", () => {
+			if (!closed) {
+				closed = true;
+				console.log("\nBye!");
+			}
+		});
+		rl.prompt();
+	}
+	async function handleExplore(trimmed, ctx$1) {
+		rl.removeAllListeners("line");
+		rl.removeAllListeners("close");
+		rl.close();
+		cleanupStdinAfterBlessed();
+		try {
+			const { createExplorerScreen } = await Promise.resolve().then(() => require("./explorer/screen.cjs"));
+			const startPath = parseExplorePath(trimmed, ctx$1);
+			await createExplorerScreen({
+				afs: ctx$1.afs,
+				startPath,
+				version: ctx$1.version,
+				onExit: () => {}
+			});
+		} catch {}
+		await new Promise((resolve) => setTimeout(resolve, 100));
+		cleanupStdinAfterBlessed();
+		process.stdout.write("\x1B[?1049l");
+		process.stdout.write("\x1B[?25h");
+		console.log("");
+		if (!closed) startReplLoop();
+	}
+	startReplLoop();
+	return new Promise((resolve) => {
+		const checkClosed = setInterval(() => {
+			if (closed) {
+				clearInterval(checkClosed);
+				if (onExit) onExit().catch(() => {}).then(resolve);
+				else resolve();
+			}
+		}, 100);
+	});
+}
+
+//#endregion
+exports.startRepl = startRepl;

package/dist/repl.d.cts

@@ -0,0 +1,15 @@
+import { AFS, AFSModule } from "@aigne/afs";
+
+//#region src/repl.d.ts
+declare function startRepl(options: {
+  cwd: string;
+  version: string;
+  onExit?: () => Promise<void>; /** Pre-created providers to mount directly (e.g. mock-based providers that can't be recreated from URI) */
+  extraProviders?: Array<{
+    provider: AFSModule;
+    mountPath: string;
+  }>;
+}): Promise<void>;
+//#endregion
+export { startRepl };
+//# sourceMappingURL=repl.d.cts.map

package/dist/repl.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.cts","names":[],"sources":["../src/repl.ts"],"mappings":";;;iBAiiBsB,SAAA,CAAU,OAAA;EAC9B,GAAA;EACA,OAAA;EACA,MAAA,SAAe,OAAA;EAEf,cAAA,GAAiB,KAAA;IAAQ,QAAA,EAAU,SAAA;IAAW,SAAA;EAAA;AAAA,IAC5C,OAAA"}

package/dist/repl.d.mts

@@ -0,0 +1,16 @@
+import "./core/executor/index.mjs";
+import { AFS, AFSModule } from "@aigne/afs";
+
+//#region src/repl.d.ts
+declare function startRepl(options: {
+  cwd: string;
+  version: string;
+  onExit?: () => Promise<void>; /** Pre-created providers to mount directly (e.g. mock-based providers that can't be recreated from URI) */
+  extraProviders?: Array<{
+    provider: AFSModule;
+    mountPath: string;
+  }>;
+}): Promise<void>;
+//#endregion
+export { startRepl };
+//# sourceMappingURL=repl.d.mts.map

package/dist/repl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repl.d.mts","names":[],"sources":["../src/repl.ts"],"mappings":";;;;iBAiiBsB,SAAA,CAAU,OAAA;EAC9B,GAAA;EACA,OAAA;EACA,MAAA,SAAe,OAAA;EAEf,cAAA,GAAiB,KAAA;IAAQ,QAAA,EAAU,SAAA;IAAW,SAAA;EAAA;AAAA,IAC5C,OAAA"}