@aigne/afs-cli 1.11.0-beta.6 → 1.11.0-beta.8

package/dist/core/executor/index.d.cts

@@ -0,0 +1,77 @@
+import { AFS } from "@aigne/afs";
+
+//#region src/core/executor/index.d.ts
+/**
+ * Result from executing a command
+ */
+interface ExecuteResult {
+  /** Whether the command executed successfully */
+  success: boolean;
+  /** The command that was executed (ls, read, write, etc.) */
+  command: string;
+  /** The raw result data from AFS */
+  result?: unknown;
+  /** Formatted output string */
+  formatted: string;
+  /** Error info if the command failed */
+  error?: {
+    /** Exit code (from ExitCode enum) */code?: number; /** Error message */
+    message: string;
+  };
+}
+/**
+ * Options for the executor
+ */
+interface ExecutorOptions {
+  /** Whether the output is for a TTY (enables colors) */
+  tty?: boolean;
+  /** Current working directory (for explore command) */
+  cwd?: string;
+  /** Version of the AFS CLI */
+  version?: string;
+}
+/**
+ * AFS Command Executor
+ *
+ * Provides a unified interface for executing AFS commands using yargs.
+ *
+ * @example
+ * ```typescript
+ * const executor = new AFSCommandExecutor(afs, { tty: false });
+ * const result = await executor.execute("afs ls /path --depth=2");
+ * console.log(result.formatted);
+ * ```
+ */
+declare class AFSCommandExecutor {
+  private afs?;
+  private options;
+  constructor(afs?: AFS, options?: ExecutorOptions);
+  /**
+   * Execute an AFS command
+   *
+   * @param argv - Command string or array of arguments
+   *   - String: "afs ls /path --depth=2" or "ls /path --depth=2"
+   *   - Array: ["ls", "/path", "--depth=2"]
+   * @returns Execution result with formatted output
+   */
+  execute(argv: string | string[]): Promise<ExecuteResult>;
+  /**
+   * Normalize argv to an array of strings
+   */
+  private normalizeArgv;
+  /**
+   * Tokenize a command string, respecting quotes
+   */
+  private tokenize;
+  /**
+   * Extract output options from args
+   */
+  private extractOutputOptions;
+  /**
+   * Extract path from args (first non-option argument after command)
+   */
+  private extractPath;
+}
+//#endregion
+export { AFSCommandExecutor, ExecuteResult, ExecutorOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/core/executor/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/core/executor/index.ts"],"mappings":";;;;;;UAkBiB,aAAA;EAQf;EANA,OAAA;EAUE;EARF,OAAA;EAUS;EART,MAAA;EAee;EAbf,SAAA;;EAEA,KAAA;IAaA,qCAXE,IAAA,WAeF;IAbE,OAAA;EAAA;AAAA;;;;UAOa,eAAA;EAsCiC;EApChD,GAAA;EAoC+C;EAlC/C,GAAA;EAkBQ;EAhBR,OAAA;AAAA;;;;;;;;;;;;;cAeW,kBAAA;EAAA,QACH,GAAA;EAAA,QACA,OAAA;cAEI,GAAA,GAAM,GAAA,EAAK,OAAA,GAAU,eAAA;;;;;;;;;EAa3B,OAAA,CAAQ,IAAA,sBAA0B,OAAA,CAAQ,aAAA;;;;UA6IxC,aAAA;;;;UAoCA,QAAA;;;;UA2CA,oBAAA;;;;UA+BA,WAAA;AAAA"}

package/dist/core/executor/index.d.mts

@@ -0,0 +1,77 @@
+import { AFS } from "@aigne/afs";
+
+//#region src/core/executor/index.d.ts
+/**
+ * Result from executing a command
+ */
+interface ExecuteResult {
+  /** Whether the command executed successfully */
+  success: boolean;
+  /** The command that was executed (ls, read, write, etc.) */
+  command: string;
+  /** The raw result data from AFS */
+  result?: unknown;
+  /** Formatted output string */
+  formatted: string;
+  /** Error info if the command failed */
+  error?: {
+    /** Exit code (from ExitCode enum) */code?: number; /** Error message */
+    message: string;
+  };
+}
+/**
+ * Options for the executor
+ */
+interface ExecutorOptions {
+  /** Whether the output is for a TTY (enables colors) */
+  tty?: boolean;
+  /** Current working directory (for explore command) */
+  cwd?: string;
+  /** Version of the AFS CLI */
+  version?: string;
+}
+/**
+ * AFS Command Executor
+ *
+ * Provides a unified interface for executing AFS commands using yargs.
+ *
+ * @example
+ * ```typescript
+ * const executor = new AFSCommandExecutor(afs, { tty: false });
+ * const result = await executor.execute("afs ls /path --depth=2");
+ * console.log(result.formatted);
+ * ```
+ */
+declare class AFSCommandExecutor {
+  private afs?;
+  private options;
+  constructor(afs?: AFS, options?: ExecutorOptions);
+  /**
+   * Execute an AFS command
+   *
+   * @param argv - Command string or array of arguments
+   *   - String: "afs ls /path --depth=2" or "ls /path --depth=2"
+   *   - Array: ["ls", "/path", "--depth=2"]
+   * @returns Execution result with formatted output
+   */
+  execute(argv: string | string[]): Promise<ExecuteResult>;
+  /**
+   * Normalize argv to an array of strings
+   */
+  private normalizeArgv;
+  /**
+   * Tokenize a command string, respecting quotes
+   */
+  private tokenize;
+  /**
+   * Extract output options from args
+   */
+  private extractOutputOptions;
+  /**
+   * Extract path from args (first non-option argument after command)
+   */
+  private extractPath;
+}
+//#endregion
+export { AFSCommandExecutor, ExecuteResult, ExecutorOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/core/executor/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../src/core/executor/index.ts"],"mappings":";;;;;;UAkBiB,aAAA;EAQf;EANA,OAAA;EAUE;EARF,OAAA;EAUS;EART,MAAA;EAee;EAbf,SAAA;;EAEA,KAAA;IAaA,qCAXE,IAAA,WAeF;IAbE,OAAA;EAAA;AAAA;;;;UAOa,eAAA;EAsCiC;EApChD,GAAA;EAoC+C;EAlC/C,GAAA;EAkBQ;EAhBR,OAAA;AAAA;;;;;;;;;;;;;cAeW,kBAAA;EAAA,QACH,GAAA;EAAA,QACA,OAAA;cAEI,GAAA,GAAM,GAAA,EAAK,OAAA,GAAU,eAAA;;;;;;;;;EAa3B,OAAA,CAAQ,IAAA,sBAA0B,OAAA,CAAQ,aAAA;;;;UA6IxC,aAAA;;;;UAoCA,QAAA;;;;UA2CA,oBAAA;;;;UA+BA,WAAA;AAAA"}

package/dist/core/executor/index.mjs

@@ -0,0 +1,195 @@
+import { commandFactories } from "../commands/index.mjs";
+import yargs from "yargs";
+
+//#region src/core/executor/index.ts
+/**
+* AFS Command Executor
+*
+* Provides a unified interface for executing AFS commands using yargs.
+*
+* @example
+* ```typescript
+* const executor = new AFSCommandExecutor(afs, { tty: false });
+* const result = await executor.execute("afs ls /path --depth=2");
+* console.log(result.formatted);
+* ```
+*/
+var AFSCommandExecutor = class {
+	afs;
+	options;
+	constructor(afs, options) {
+		this.afs = afs;
+		this.options = options ?? {};
+	}
+	/**
+	* Execute an AFS command
+	*
+	* @param argv - Command string or array of arguments
+	*   - String: "afs ls /path --depth=2" or "ls /path --depth=2"
+	*   - Array: ["ls", "/path", "--depth=2"]
+	* @returns Execution result with formatted output
+	*/
+	async execute(argv) {
+		const normalizedArgs = this.normalizeArgv(argv);
+		let commandResult;
+		const outputOptions = this.extractOutputOptions(normalizedArgs);
+		const factoryOptions = {
+			afs: this.afs,
+			argv: normalizedArgs,
+			cwd: this.options.cwd,
+			onResult: (result) => {
+				commandResult = result;
+			}
+		};
+		let parser = yargs(normalizedArgs).scriptName("afs").usage("$0 <command> [options]").option("json", {
+			type: "boolean",
+			description: "Output in JSON format",
+			global: true
+		}).option("yaml", {
+			type: "boolean",
+			description: "Output in YAML format",
+			global: true
+		}).option("view", {
+			type: "string",
+			choices: [
+				"default",
+				"llm",
+				"human"
+			],
+			default: "default",
+			description: "Output view format",
+			global: true
+		}).option("interactive", {
+			alias: "i",
+			type: "boolean",
+			description: "Start interactive REPL mode",
+			global: false
+		}).help(true).alias("h", "help").version(this.options.version || "unknown").alias("v", "version").demandCommand().showHelpOnFail(true).exitProcess(false);
+		for (const factory of commandFactories) parser = parser.command(factory(factoryOptions));
+		try {
+			let output;
+			let error;
+			const parsed = await parser.parseAsync(normalizedArgs, {}, (e, _, o) => {
+				if (e) error = e;
+				output = o;
+			});
+			if (error) return {
+				success: false,
+				command: normalizedArgs[0] || "unknown",
+				result: void 0,
+				formatted: output,
+				error: { message: error.message }
+			};
+			if (parsed.help) return {
+				success: true,
+				command: "help",
+				formatted: output
+			};
+			if (parsed.version) return {
+				success: true,
+				command: "version",
+				formatted: output
+			};
+			if (!commandResult) throw new Error("Command not found");
+			const view = outputOptions.json ? "json" : outputOptions.yaml ? "yaml" : outputOptions.view;
+			const formatted = commandResult.format(commandResult.result, view, { path: this.extractPath(normalizedArgs) });
+			if (commandResult.error) return {
+				success: false,
+				command: commandResult.command,
+				result: commandResult.result,
+				formatted,
+				error: commandResult.error
+			};
+			return {
+				success: true,
+				command: commandResult.command,
+				result: commandResult.result,
+				formatted
+			};
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			return {
+				success: false,
+				command: normalizedArgs[0] || "unknown",
+				result: void 0,
+				formatted: `ERROR: ${errorMessage}`,
+				error: { message: errorMessage }
+			};
+		}
+	}
+	/**
+	* Normalize argv to an array of strings
+	*/
+	normalizeArgv(argv) {
+		if (typeof argv === "string") return this.tokenize(argv);
+		const filtered = [];
+		let foundCommand = false;
+		for (const arg of argv) {
+			if (!foundCommand && (arg.includes("node") || arg.includes("bun") || arg.endsWith(".js") || arg.endsWith(".ts"))) continue;
+			if (!foundCommand && arg === "afs") continue;
+			filtered.push(arg);
+			if (!arg.startsWith("-")) foundCommand = true;
+		}
+		return filtered;
+	}
+	/**
+	* Tokenize a command string, respecting quotes
+	*/
+	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);
+		if (tokens[0] === "afs") tokens.shift();
+		return tokens;
+	}
+	/**
+	* Extract output options from args
+	*/
+	extractOutputOptions(args) {
+		let json = false;
+		let yaml = false;
+		let view;
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if (arg === "--json") json = true;
+			if (arg === "--yaml") yaml = true;
+			if (arg.startsWith("--view=")) view = arg.slice(7);
+			else if (arg === "--view" && args[i + 1] && !args[i + 1].startsWith("-")) view = args[i + 1];
+		}
+		if (!view) view = this.options.tty ? "human" : "default";
+		return {
+			json,
+			yaml,
+			view
+		};
+	}
+	/**
+	* Extract path from args (first non-option argument after command)
+	*/
+	extractPath(args) {
+		for (let i = 1; i < args.length; i++) {
+			const arg = args[i];
+			if (!arg.startsWith("-")) return arg;
+		}
+	}
+};
+
+//#endregion
+export { AFSCommandExecutor };
+//# sourceMappingURL=index.mjs.map

package/dist/core/executor/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/core/executor/index.ts"],"sourcesContent":["/**\n * AFS Command Executor\n *\n * Unified command execution interface using yargs and CommandFactory pattern.\n */\n\nimport type { AFS } from \"@aigne/afs\";\nimport yargs from \"yargs\";\nimport {\n  type CommandFactoryOptions,\n  type CommandOutput,\n  commandFactories,\n} from \"../commands/index.js\";\nimport type { ViewType } from \"../types.js\";\n\n/**\n * Result from executing a command\n */\nexport interface ExecuteResult {\n  /** Whether the command executed successfully */\n  success: boolean;\n  /** The command that was executed (ls, read, write, etc.) */\n  command: string;\n  /** The raw result data from AFS */\n  result?: unknown;\n  /** Formatted output string */\n  formatted: string;\n  /** Error info if the command failed */\n  error?: {\n    /** Exit code (from ExitCode enum) */\n    code?: number;\n    /** Error message */\n    message: string;\n  };\n}\n\n/**\n * Options for the executor\n */\nexport interface ExecutorOptions {\n  /** Whether the output is for a TTY (enables colors) */\n  tty?: boolean;\n  /** Current working directory (for explore command) */\n  cwd?: string;\n  /** Version of the AFS CLI */\n  version?: string;\n}\n\n/**\n * AFS Command Executor\n *\n * Provides a unified interface for executing AFS commands using yargs.\n *\n * @example\n * ```typescript\n * const executor = new AFSCommandExecutor(afs, { tty: false });\n * const result = await executor.execute(\"afs ls /path --depth=2\");\n * console.log(result.formatted);\n * ```\n */\nexport class AFSCommandExecutor {\n  private afs?: AFS;\n  private options: ExecutorOptions;\n\n  constructor(afs?: AFS, options?: ExecutorOptions) {\n    this.afs = afs;\n    this.options = options ?? {};\n  }\n\n  /**\n   * Execute an AFS command\n   *\n   * @param argv - Command string or array of arguments\n   *   - String: \"afs ls /path --depth=2\" or \"ls /path --depth=2\"\n   *   - Array: [\"ls\", \"/path\", \"--depth=2\"]\n   * @returns Execution result with formatted output\n   */\n  async execute(argv: string | string[]): Promise<ExecuteResult> {\n    const normalizedArgs = this.normalizeArgv(argv);\n\n    // Capture command result\n    let commandResult: CommandOutput | undefined;\n\n    // Determine output format from args\n    const outputOptions = this.extractOutputOptions(normalizedArgs);\n\n    // Create factory options\n    const factoryOptions: CommandFactoryOptions = {\n      afs: this.afs,\n      argv: normalizedArgs,\n      cwd: this.options.cwd,\n      onResult: (result) => {\n        commandResult = result;\n      },\n    };\n\n    // Build yargs parser with all commands\n    let parser = yargs(normalizedArgs)\n      .scriptName(\"afs\")\n      .usage(\"$0 <command> [options]\")\n      .option(\"json\", {\n        type: \"boolean\",\n        description: \"Output in JSON format\",\n        global: true,\n      })\n      .option(\"yaml\", {\n        type: \"boolean\",\n        description: \"Output in YAML format\",\n        global: true,\n      })\n      .option(\"view\", {\n        type: \"string\",\n        choices: [\"default\", \"llm\", \"human\"],\n        default: \"default\",\n        description: \"Output view format\",\n        global: true,\n      })\n      .option(\"interactive\", {\n        alias: \"i\",\n        type: \"boolean\",\n        description: \"Start interactive REPL mode\",\n        global: false,\n      })\n      .help(true)\n      .alias(\"h\", \"help\")\n      .version(this.options.version || \"unknown\")\n      .alias(\"v\", \"version\")\n      .demandCommand()\n      .showHelpOnFail(true)\n      .exitProcess(false);\n\n    // Register all commands from factories\n    for (const factory of commandFactories) {\n      parser = parser.command(factory(factoryOptions));\n    }\n\n    // Parse and execute\n    try {\n      let output: string | undefined;\n      let error: Error | undefined;\n\n      const parsed = await parser.parseAsync(normalizedArgs, {}, (e, _, o) => {\n        if (e) error = e;\n        output = o;\n      });\n\n      if (error) {\n        return {\n          success: false,\n          command: normalizedArgs[0] || \"unknown\",\n          result: undefined,\n          formatted: output!,\n          error: { message: error.message },\n        };\n      }\n\n      if (parsed.help) {\n        return {\n          success: true,\n          command: \"help\",\n          formatted: output!,\n        };\n      }\n      if (parsed.version) {\n        return {\n          success: true,\n          command: \"version\",\n          formatted: output!,\n        };\n      }\n\n      if (!commandResult) {\n        throw new Error(\"Command not found\");\n      }\n\n      // Always use the formatter - it handles json/llm/human views\n      const view: ViewType = outputOptions.json\n        ? \"json\"\n        : outputOptions.yaml\n          ? \"yaml\"\n          : outputOptions.view;\n      const formatted = commandResult.format(commandResult.result, view, {\n        path: this.extractPath(normalizedArgs),\n      });\n\n      // Check if command indicated failure\n      if (commandResult.error) {\n        return {\n          success: false,\n          command: commandResult.command,\n          result: commandResult.result,\n          formatted,\n          error: commandResult.error,\n        };\n      }\n\n      return {\n        success: true,\n        command: commandResult.command,\n        result: commandResult.result,\n        formatted,\n      };\n    } catch (error) {\n      const errorMessage = error instanceof Error ? error.message : String(error);\n\n      return {\n        success: false,\n        command: normalizedArgs[0] || \"unknown\",\n        result: undefined,\n        formatted: `ERROR: ${errorMessage}`,\n        error: { message: errorMessage },\n      };\n    }\n  }\n\n  /**\n   * Normalize argv to an array of strings\n   */\n  private normalizeArgv(argv: string | string[]): string[] {\n    if (typeof argv === \"string\") {\n      // Parse quoted strings properly\n      return this.tokenize(argv);\n    }\n\n    // Filter array input\n    const filtered: string[] = [];\n    let foundCommand = false;\n\n    for (const arg of argv) {\n      // Skip node and script paths (for process.argv format)\n      if (\n        !foundCommand &&\n        (arg.includes(\"node\") || arg.includes(\"bun\") || arg.endsWith(\".js\") || arg.endsWith(\".ts\"))\n      ) {\n        continue;\n      }\n\n      // Skip \"afs\" prefix\n      if (!foundCommand && arg === \"afs\") {\n        continue;\n      }\n\n      filtered.push(arg);\n      if (!arg.startsWith(\"-\")) {\n        foundCommand = true;\n      }\n    }\n\n    return filtered;\n  }\n\n  /**\n   * Tokenize a command string, respecting quotes\n   */\n  private tokenize(input: string): string[] {\n    const tokens: string[] = [];\n    let current = \"\";\n    let inQuote = false;\n    let quoteChar = \"\";\n\n    for (let i = 0; i < input.length; i++) {\n      const char = input[i]!;\n\n      if (inQuote) {\n        if (char === quoteChar) {\n          inQuote = false;\n        } else {\n          current += char;\n        }\n      } else if (char === '\"' || char === \"'\") {\n        inQuote = true;\n        quoteChar = char;\n      } else if (char === \" \" || char === \"\\t\") {\n        if (current) {\n          tokens.push(current);\n          current = \"\";\n        }\n      } else {\n        current += char;\n      }\n    }\n\n    if (current) {\n      tokens.push(current);\n    }\n\n    // Filter out \"afs\" prefix if present\n    if (tokens[0] === \"afs\") {\n      tokens.shift();\n    }\n\n    return tokens;\n  }\n\n  /**\n   * Extract output options from args\n   */\n  private extractOutputOptions(args: string[]): {\n    json: boolean;\n    yaml: boolean;\n    view: ViewType;\n  } {\n    let json = false;\n    let yaml = false;\n    let view: ViewType | undefined;\n\n    for (let i = 0; i < args.length; i++) {\n      const arg = args[i]!;\n      if (arg === \"--json\") json = true;\n      if (arg === \"--yaml\") yaml = true;\n      if (arg.startsWith(\"--view=\")) {\n        view = arg.slice(7) as ViewType;\n      } else if (arg === \"--view\" && args[i + 1] && !args[i + 1]!.startsWith(\"-\")) {\n        view = args[i + 1] as ViewType;\n      }\n    }\n\n    // Default to human view in TTY, default otherwise\n    if (!view) {\n      view = this.options.tty ? \"human\" : \"default\";\n    }\n\n    return { json, yaml, view };\n  }\n\n  /**\n   * Extract path from args (first non-option argument after command)\n   */\n  private extractPath(args: string[]): string | undefined {\n    for (let i = 1; i < args.length; i++) {\n      const arg = args[i]!;\n      if (!arg.startsWith(\"-\")) {\n        return arg;\n      }\n    }\n    return undefined;\n  }\n}\n"],"mappings":"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"}

package/dist/core/formatters/delete.cjs

@@ -0,0 +1,37 @@
+
+//#region src/core/formatters/delete.ts
+/**
+* Format delete output for different views
+*
+* @param result - AFS delete result (native type)
+* @param view - View type (default, json, llm, human)
+* @param options - Format options (path for display)
+* @returns Formatted string (no ANSI colors)
+*/
+function formatDeleteOutput(result, view, options) {
+	const path = options?.path;
+	switch (view) {
+		case "json": return JSON.stringify(result, null, 2);
+		case "llm": return formatLlm(result, path);
+		case "human": return formatHuman(result, path);
+		default: return formatDefault(result, path);
+	}
+}
+function formatDefault(result, path) {
+	if (path) return path;
+	return result.message || "Deleted";
+}
+function formatLlm(result, path) {
+	const lines = [];
+	lines.push(`DELETE ${path || "path"}`);
+	lines.push("STATUS SUCCESS");
+	if (result.message) lines.push(`MESSAGE ${result.message}`);
+	return lines.join("\n");
+}
+function formatHuman(result, path) {
+	if (path) return `Deleted: ${path}`;
+	return result.message || "Deleted successfully";
+}
+
+//#endregion
+exports.formatDeleteOutput = formatDeleteOutput;

package/dist/core/formatters/delete.d.cts

@@ -0,0 +1,18 @@
+import { ViewType } from "../types.cjs";
+import { AFSDeleteResult } from "@aigne/afs";
+
+//#region src/core/formatters/delete.d.ts
+/**
+ * Format delete output for different views
+ *
+ * @param result - AFS delete result (native type)
+ * @param view - View type (default, json, llm, human)
+ * @param options - Format options (path for display)
+ * @returns Formatted string (no ANSI colors)
+ */
+declare function formatDeleteOutput(result: AFSDeleteResult, view: ViewType, options?: {
+  path?: string;
+}): string;
+//#endregion
+export { formatDeleteOutput };
+//# sourceMappingURL=delete.d.cts.map

package/dist/core/formatters/delete.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.cts","names":[],"sources":["../../../src/core/formatters/delete.ts"],"mappings":";;;;;;;;;;;;iBAkBgB,kBAAA,CACd,MAAA,EAAQ,eAAA,EACR,IAAA,EAAM,QAAA,EACN,OAAA;EAAY,IAAA;AAAA"}

package/dist/core/formatters/delete.d.mts

@@ -0,0 +1,18 @@
+import { ViewType } from "../types.mjs";
+import { AFSDeleteResult } from "@aigne/afs";
+
+//#region src/core/formatters/delete.d.ts
+/**
+ * Format delete output for different views
+ *
+ * @param result - AFS delete result (native type)
+ * @param view - View type (default, json, llm, human)
+ * @param options - Format options (path for display)
+ * @returns Formatted string (no ANSI colors)
+ */
+declare function formatDeleteOutput(result: AFSDeleteResult, view: ViewType, options?: {
+  path?: string;
+}): string;
+//#endregion
+export { formatDeleteOutput };
+//# sourceMappingURL=delete.d.mts.map

package/dist/core/formatters/delete.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.mts","names":[],"sources":["../../../src/core/formatters/delete.ts"],"mappings":";;;;;;;;;;;;iBAkBgB,kBAAA,CACd,MAAA,EAAQ,eAAA,EACR,IAAA,EAAM,QAAA,EACN,OAAA;EAAY,IAAA;AAAA"}

package/dist/core/formatters/delete.mjs

@@ -0,0 +1,37 @@
+//#region src/core/formatters/delete.ts
+/**
+* Format delete output for different views
+*
+* @param result - AFS delete result (native type)
+* @param view - View type (default, json, llm, human)
+* @param options - Format options (path for display)
+* @returns Formatted string (no ANSI colors)
+*/
+function formatDeleteOutput(result, view, options) {
+	const path = options?.path;
+	switch (view) {
+		case "json": return JSON.stringify(result, null, 2);
+		case "llm": return formatLlm(result, path);
+		case "human": return formatHuman(result, path);
+		default: return formatDefault(result, path);
+	}
+}
+function formatDefault(result, path) {
+	if (path) return path;
+	return result.message || "Deleted";
+}
+function formatLlm(result, path) {
+	const lines = [];
+	lines.push(`DELETE ${path || "path"}`);
+	lines.push("STATUS SUCCESS");
+	if (result.message) lines.push(`MESSAGE ${result.message}`);
+	return lines.join("\n");
+}
+function formatHuman(result, path) {
+	if (path) return `Deleted: ${path}`;
+	return result.message || "Deleted successfully";
+}
+
+//#endregion
+export { formatDeleteOutput };
+//# sourceMappingURL=delete.mjs.map

package/dist/core/formatters/delete.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.mjs","names":[],"sources":["../../../src/core/formatters/delete.ts"],"sourcesContent":["/**\n * delete Formatter - Core Implementation\n *\n * Formats delete output without colors.\n * Accepts AFS native AFSDeleteResult directly.\n */\n\nimport type { AFSDeleteResult } from \"@aigne/afs\";\nimport type { ViewType } from \"../types.js\";\n\n/**\n * Format delete output for different views\n *\n * @param result - AFS delete result (native type)\n * @param view - View type (default, json, llm, human)\n * @param options - Format options (path for display)\n * @returns Formatted string (no ANSI colors)\n */\nexport function formatDeleteOutput(\n  result: AFSDeleteResult,\n  view: ViewType,\n  options?: { path?: string },\n): string {\n  const path = options?.path;\n  switch (view) {\n    case \"json\":\n      return JSON.stringify(result, null, 2);\n    case \"llm\":\n      return formatLlm(result, path);\n    case \"human\":\n      return formatHuman(result, path);\n    default:\n      return formatDefault(result, path);\n  }\n}\n\nfunction formatDefault(result: AFSDeleteResult, path?: string): string {\n  if (path) {\n    return path;\n  }\n  return result.message || \"Deleted\";\n}\n\nfunction formatLlm(result: AFSDeleteResult, path?: string): string {\n  const lines: string[] = [];\n\n  lines.push(`DELETE ${path || \"path\"}`);\n  lines.push(\"STATUS SUCCESS\");\n\n  if (result.message) {\n    lines.push(`MESSAGE ${result.message}`);\n  }\n\n  return lines.join(\"\\n\");\n}\n\nfunction formatHuman(result: AFSDeleteResult, path?: string): string {\n  if (path) {\n    return `Deleted: ${path}`;\n  }\n  return result.message || \"Deleted successfully\";\n}\n"],"mappings":";;;;;;;;;AAkBA,SAAgB,mBACd,QACA,MACA,SACQ;CACR,MAAM,OAAO,SAAS;AACtB,SAAQ,MAAR;EACE,KAAK,OACH,QAAO,KAAK,UAAU,QAAQ,MAAM,EAAE;EACxC,KAAK,MACH,QAAO,UAAU,QAAQ,KAAK;EAChC,KAAK,QACH,QAAO,YAAY,QAAQ,KAAK;EAClC,QACE,QAAO,cAAc,QAAQ,KAAK;;;AAIxC,SAAS,cAAc,QAAyB,MAAuB;AACrE,KAAI,KACF,QAAO;AAET,QAAO,OAAO,WAAW;;AAG3B,SAAS,UAAU,QAAyB,MAAuB;CACjE,MAAM,QAAkB,EAAE;AAE1B,OAAM,KAAK,UAAU,QAAQ,SAAS;AACtC,OAAM,KAAK,iBAAiB;AAE5B,KAAI,OAAO,QACT,OAAM,KAAK,WAAW,OAAO,UAAU;AAGzC,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,YAAY,QAAyB,MAAuB;AACnE,KAAI,KACF,QAAO,YAAY;AAErB,QAAO,OAAO,WAAW"}

package/dist/core/formatters/exec.cjs

@@ -0,0 +1,60 @@
+
+//#region src/core/formatters/exec.ts
+/**
+* Format exec output for different views
+*
+* @param result - AFS exec result (native type)
+* @param view - View type (default, json, llm, human)
+* @param options - Format options (path for display)
+* @returns Formatted string (no ANSI colors)
+*/
+function formatExecOutput(result, view, options) {
+	const path = options?.path;
+	switch (view) {
+		case "json": return JSON.stringify(result, null, 2);
+		case "llm": return formatLlm(result, path);
+		case "human": return formatHuman(result, path);
+		default: return formatDefault(result, path);
+	}
+}
+function formatDefault(result, path) {
+	if (result.success) {
+		if (result.data) return JSON.stringify(result.data);
+		return path ? `OK ${path}` : "OK";
+	}
+	return `${result.error?.code || "ERROR"} ${path || ""} ${result.error?.message || ""}`.trim();
+}
+function formatLlm(result, path) {
+	const lines = [];
+	if (path) lines.push(`EXEC ${path}`);
+	lines.push(`STATUS ${result.success ? "SUCCESS" : "FAILED"}`);
+	if (result.data) lines.push(`DATA ${JSON.stringify(result.data)}`);
+	if (!result.success && result.error) {
+		if (result.error.code) lines.push(`ERROR ${result.error.code}`);
+		if (result.error.message) lines.push(`MESSAGE ${result.error.message}`);
+		if (result.error.details) lines.push(`DETAILS ${JSON.stringify(result.error.details)}`);
+	}
+	return lines.join("\n");
+}
+function formatHuman(result, path) {
+	if (result.success) {
+		const lines$1 = path ? [`Executed: ${path}`] : ["Executed successfully"];
+		if (result.data) {
+			lines$1.push("");
+			lines$1.push(JSON.stringify(result.data, null, 2));
+		}
+		return lines$1.join("\n");
+	}
+	const lines = path ? [`Failed: ${path}`] : ["Execution failed"];
+	lines.push("");
+	if (result.error?.code) lines.push(`Error: ${result.error.code}`);
+	if (result.error?.message) lines.push(`Message: ${result.error.message}`);
+	if (result.error?.details) {
+		lines.push("Details:");
+		for (const [key, value] of Object.entries(result.error.details)) lines.push(`  ${key}: ${JSON.stringify(value)}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+exports.formatExecOutput = formatExecOutput;

package/dist/core/formatters/exec.d.cts

@@ -0,0 +1,18 @@
+import { ViewType } from "../types.cjs";
+import { AFSExecResult } from "@aigne/afs";
+
+//#region src/core/formatters/exec.d.ts
+/**
+ * Format exec output for different views
+ *
+ * @param result - AFS exec result (native type)
+ * @param view - View type (default, json, llm, human)
+ * @param options - Format options (path for display)
+ * @returns Formatted string (no ANSI colors)
+ */
+declare function formatExecOutput(result: AFSExecResult, view: ViewType, options?: {
+  path?: string;
+}): string;
+//#endregion
+export { formatExecOutput };
+//# sourceMappingURL=exec.d.cts.map

package/dist/core/formatters/exec.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.cts","names":[],"sources":["../../../src/core/formatters/exec.ts"],"mappings":";;;;;;;;;;;;iBAkBgB,gBAAA,CACd,MAAA,EAAQ,aAAA,EACR,IAAA,EAAM,QAAA,EACN,OAAA;EAAY,IAAA;AAAA"}

package/dist/core/formatters/exec.d.mts

@@ -0,0 +1,18 @@
+import { ViewType } from "../types.mjs";
+import { AFSExecResult } from "@aigne/afs";
+
+//#region src/core/formatters/exec.d.ts
+/**
+ * Format exec output for different views
+ *
+ * @param result - AFS exec result (native type)
+ * @param view - View type (default, json, llm, human)
+ * @param options - Format options (path for display)
+ * @returns Formatted string (no ANSI colors)
+ */
+declare function formatExecOutput(result: AFSExecResult, view: ViewType, options?: {
+  path?: string;
+}): string;
+//#endregion
+export { formatExecOutput };
+//# sourceMappingURL=exec.d.mts.map

package/dist/core/formatters/exec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.mts","names":[],"sources":["../../../src/core/formatters/exec.ts"],"mappings":";;;;;;;;;;;;iBAkBgB,gBAAA,CACd,MAAA,EAAQ,aAAA,EACR,IAAA,EAAM,QAAA,EACN,OAAA;EAAY,IAAA;AAAA"}