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

package/dist/core/helpers/exec-args.cjs

@@ -0,0 +1,142 @@
+const require_stdin = require('./stdin.cjs');
+
+//#region src/core/helpers/exec-args.ts
+/**
+* Reserved CLI option names that should not be passed as exec arguments
+*/
+const RESERVED_OPTIONS = new Set([
+	"json",
+	"yaml",
+	"view",
+	"help",
+	"h",
+	"version",
+	"V",
+	"_",
+	"$0",
+	"executable_path",
+	"executablePath",
+	"args"
+]);
+/**
+* Parse exec arguments from CLI options, with optional schema-aware type coercion
+*
+* Priority: CLI flags > stdin > --args
+*
+* @param options - CLI options object
+* @param inputSchema - Optional JSON Schema for type coercion
+* @returns Parsed arguments for exec
+*/
+function parseExecArgs(options, inputSchema) {
+	let result = {};
+	if (options.args && typeof options.args === "string") try {
+		const parsed = JSON.parse(options.args);
+		if (typeof parsed === "object" && parsed !== null) result = { ...parsed };
+	} catch (e) {
+		throw new Error(`Invalid JSON in --args: ${e.message}`);
+	}
+	const properties = inputSchema?.properties;
+	for (const [key, value] of Object.entries(options)) {
+		const isSchemaProperty = inputSchema?.properties?.[key] !== void 0;
+		if (RESERVED_OPTIONS.has(key) && !isSchemaProperty || value === void 0 || value === null) continue;
+		const propSchema = properties?.[key];
+		result[key] = parseValueBySchema(value, propSchema, key);
+	}
+	return result;
+}
+/**
+* Parse exec arguments with stdin support (async version)
+*
+* Priority: CLI flags > stdin > --args
+*
+* @param options - CLI options object from yargs
+* @param inputSchema - Optional JSON Schema for type-aware coercion
+* @returns Parsed arguments for exec
+*/
+async function parseExecArgsWithStdin(options, inputSchema) {
+	let result = {};
+	if (options.args && typeof options.args === "string") try {
+		const parsed = JSON.parse(options.args);
+		if (typeof parsed === "object" && parsed !== null) result = { ...parsed };
+	} catch (e) {
+		throw new Error(`Invalid JSON in --args: ${e.message}`);
+	}
+	const stdinContent = await require_stdin.readStdin();
+	if (stdinContent) try {
+		const parsed = JSON.parse(stdinContent);
+		if (typeof parsed === "object" && parsed !== null) result = {
+			...result,
+			...parsed
+		};
+	} catch (e) {
+		throw new Error(`Invalid JSON in stdin: ${e.message}`);
+	}
+	const properties = inputSchema?.properties;
+	for (const [key, value] of Object.entries(options)) {
+		const isSchemaProperty = inputSchema?.properties?.[key] !== void 0;
+		if (RESERVED_OPTIONS.has(key) && !isSchemaProperty || value === void 0 || value === null) continue;
+		const propSchema = properties?.[key];
+		result[key] = parseValueBySchema(value, propSchema, key);
+	}
+	return result;
+}
+/**
+* Parse a value according to its JSON Schema type
+*
+* @param value - The value to parse (typically a string from CLI)
+* @param schema - The JSON Schema for this property
+* @param paramName - Parameter name for error messages
+* @returns Parsed value with appropriate type
+*/
+function parseValueBySchema(value, schema, paramName) {
+	if (typeof value !== "string") return value;
+	if (!schema) return value;
+	const schemaType = schema.type;
+	switch (schemaType) {
+		case "integer": {
+			const num = Number(value);
+			if (Number.isNaN(num)) throw new Error(`Invalid integer for '${paramName}': ${value}\nExpected: integer`);
+			return Math.floor(num);
+		}
+		case "number": {
+			const num = Number(value);
+			if (Number.isNaN(num)) throw new Error(`Invalid number for '${paramName}': ${value}\nExpected: number`);
+			return num;
+		}
+		case "boolean":
+			if (value === "true") return true;
+			if (value === "false") return false;
+			throw new Error(`Invalid boolean for '${paramName}': ${value}\nExpected: "true" or "false"`);
+		case "array":
+		case "object": try {
+			return JSON.parse(value);
+		} catch (e) {
+			const errorMsg = e instanceof Error ? e.message : String(e);
+			throw new Error(`Invalid JSON for '${paramName}': ${errorMsg}\nValue: ${value}\nHint: For ${schemaType}s, use valid JSON syntax. ` + (schemaType === "array" ? "Arrays use [...], e.g., '[\"a\",\"b\"]'" : "Objects use {...}, e.g., '{\"key\":\"value\"}'"));
+		}
+		default: return value;
+	}
+}
+/**
+* Convert JSON Schema type to yargs type
+*
+* @param schemaType - JSON Schema type
+* @returns yargs type string
+*/
+function schemaTypeToYargs(schemaType) {
+	switch (schemaType) {
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "array":
+		case "object": return "string";
+		default: return "string";
+	}
+}
+
+//#endregion
+exports.RESERVED_OPTIONS = RESERVED_OPTIONS;
+exports.parseExecArgs = parseExecArgs;
+exports.parseExecArgsWithStdin = parseExecArgsWithStdin;
+exports.parseValueBySchema = parseValueBySchema;
+exports.schemaTypeToYargs = schemaTypeToYargs;

package/dist/core/helpers/exec-args.d.cts

@@ -0,0 +1,46 @@
+import { JSONSchema } from "../types.cjs";
+
+//#region src/core/helpers/exec-args.d.ts
+/**
+ * Reserved CLI option names that should not be passed as exec arguments
+ */
+declare const RESERVED_OPTIONS: Set<string>;
+/**
+ * Parse exec arguments from CLI options, with optional schema-aware type coercion
+ *
+ * Priority: CLI flags > stdin > --args
+ *
+ * @param options - CLI options object
+ * @param inputSchema - Optional JSON Schema for type coercion
+ * @returns Parsed arguments for exec
+ */
+declare function parseExecArgs(options: Record<string, unknown>, inputSchema?: JSONSchema): Record<string, unknown>;
+/**
+ * Parse exec arguments with stdin support (async version)
+ *
+ * Priority: CLI flags > stdin > --args
+ *
+ * @param options - CLI options object from yargs
+ * @param inputSchema - Optional JSON Schema for type-aware coercion
+ * @returns Parsed arguments for exec
+ */
+declare function parseExecArgsWithStdin(options: Record<string, unknown>, inputSchema?: JSONSchema): Promise<Record<string, unknown>>;
+/**
+ * Parse a value according to its JSON Schema type
+ *
+ * @param value - The value to parse (typically a string from CLI)
+ * @param schema - The JSON Schema for this property
+ * @param paramName - Parameter name for error messages
+ * @returns Parsed value with appropriate type
+ */
+declare function parseValueBySchema(value: unknown, schema: JSONSchema | undefined, paramName: string): unknown;
+/**
+ * Convert JSON Schema type to yargs type
+ *
+ * @param schemaType - JSON Schema type
+ * @returns yargs type string
+ */
+declare function schemaTypeToYargs(schemaType: JSONSchema["type"]): "string" | "number" | "boolean" | "array";
+//#endregion
+export { RESERVED_OPTIONS, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, schemaTypeToYargs };
+//# sourceMappingURL=exec-args.d.cts.map

package/dist/core/helpers/exec-args.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-args.d.cts","names":[],"sources":["../../../src/core/helpers/exec-args.ts"],"mappings":";;;;;AAoCA;cAxBa,gBAAA,EAAgB,GAAA;;;;;;;;;;iBAwBb,aAAA,CACd,OAAA,EAAS,MAAA,mBACT,WAAA,GAAc,UAAA,GACb,MAAA;;;;AA0CH;;;;;;iBAAsB,sBAAA,CACpB,OAAA,EAAS,MAAA,mBACT,WAAA,GAAc,UAAA,GACb,OAAA,CAAQ,MAAA;;;;;;;;;iBAsDK,kBAAA,CACd,KAAA,WACA,MAAA,EAAQ,UAAA,cACR,SAAA;;AAHF;;;;;iBAqEgB,iBAAA,CACd,UAAA,EAAY,UAAA"}

package/dist/core/helpers/exec-args.d.mts

@@ -0,0 +1,46 @@
+import { JSONSchema } from "../types.mjs";
+
+//#region src/core/helpers/exec-args.d.ts
+/**
+ * Reserved CLI option names that should not be passed as exec arguments
+ */
+declare const RESERVED_OPTIONS: Set<string>;
+/**
+ * Parse exec arguments from CLI options, with optional schema-aware type coercion
+ *
+ * Priority: CLI flags > stdin > --args
+ *
+ * @param options - CLI options object
+ * @param inputSchema - Optional JSON Schema for type coercion
+ * @returns Parsed arguments for exec
+ */
+declare function parseExecArgs(options: Record<string, unknown>, inputSchema?: JSONSchema): Record<string, unknown>;
+/**
+ * Parse exec arguments with stdin support (async version)
+ *
+ * Priority: CLI flags > stdin > --args
+ *
+ * @param options - CLI options object from yargs
+ * @param inputSchema - Optional JSON Schema for type-aware coercion
+ * @returns Parsed arguments for exec
+ */
+declare function parseExecArgsWithStdin(options: Record<string, unknown>, inputSchema?: JSONSchema): Promise<Record<string, unknown>>;
+/**
+ * Parse a value according to its JSON Schema type
+ *
+ * @param value - The value to parse (typically a string from CLI)
+ * @param schema - The JSON Schema for this property
+ * @param paramName - Parameter name for error messages
+ * @returns Parsed value with appropriate type
+ */
+declare function parseValueBySchema(value: unknown, schema: JSONSchema | undefined, paramName: string): unknown;
+/**
+ * Convert JSON Schema type to yargs type
+ *
+ * @param schemaType - JSON Schema type
+ * @returns yargs type string
+ */
+declare function schemaTypeToYargs(schemaType: JSONSchema["type"]): "string" | "number" | "boolean" | "array";
+//#endregion
+export { RESERVED_OPTIONS, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, schemaTypeToYargs };
+//# sourceMappingURL=exec-args.d.mts.map

package/dist/core/helpers/exec-args.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-args.d.mts","names":[],"sources":["../../../src/core/helpers/exec-args.ts"],"mappings":";;;;;AAoCA;cAxBa,gBAAA,EAAgB,GAAA;;;;;;;;;;iBAwBb,aAAA,CACd,OAAA,EAAS,MAAA,mBACT,WAAA,GAAc,UAAA,GACb,MAAA;;;;AA0CH;;;;;;iBAAsB,sBAAA,CACpB,OAAA,EAAS,MAAA,mBACT,WAAA,GAAc,UAAA,GACb,OAAA,CAAQ,MAAA;;;;;;;;;iBAsDK,kBAAA,CACd,KAAA,WACA,MAAA,EAAQ,UAAA,cACR,SAAA;;AAHF;;;;;iBAqEgB,iBAAA,CACd,UAAA,EAAY,UAAA"}

package/dist/core/helpers/exec-args.mjs

@@ -0,0 +1,139 @@
+import { readStdin } from "./stdin.mjs";
+
+//#region src/core/helpers/exec-args.ts
+/**
+* Reserved CLI option names that should not be passed as exec arguments
+*/
+const RESERVED_OPTIONS = new Set([
+	"json",
+	"yaml",
+	"view",
+	"help",
+	"h",
+	"version",
+	"V",
+	"_",
+	"$0",
+	"executable_path",
+	"executablePath",
+	"args"
+]);
+/**
+* Parse exec arguments from CLI options, with optional schema-aware type coercion
+*
+* Priority: CLI flags > stdin > --args
+*
+* @param options - CLI options object
+* @param inputSchema - Optional JSON Schema for type coercion
+* @returns Parsed arguments for exec
+*/
+function parseExecArgs(options, inputSchema) {
+	let result = {};
+	if (options.args && typeof options.args === "string") try {
+		const parsed = JSON.parse(options.args);
+		if (typeof parsed === "object" && parsed !== null) result = { ...parsed };
+	} catch (e) {
+		throw new Error(`Invalid JSON in --args: ${e.message}`);
+	}
+	const properties = inputSchema?.properties;
+	for (const [key, value] of Object.entries(options)) {
+		const isSchemaProperty = inputSchema?.properties?.[key] !== void 0;
+		if (RESERVED_OPTIONS.has(key) && !isSchemaProperty || value === void 0 || value === null) continue;
+		const propSchema = properties?.[key];
+		result[key] = parseValueBySchema(value, propSchema, key);
+	}
+	return result;
+}
+/**
+* Parse exec arguments with stdin support (async version)
+*
+* Priority: CLI flags > stdin > --args
+*
+* @param options - CLI options object from yargs
+* @param inputSchema - Optional JSON Schema for type-aware coercion
+* @returns Parsed arguments for exec
+*/
+async function parseExecArgsWithStdin(options, inputSchema) {
+	let result = {};
+	if (options.args && typeof options.args === "string") try {
+		const parsed = JSON.parse(options.args);
+		if (typeof parsed === "object" && parsed !== null) result = { ...parsed };
+	} catch (e) {
+		throw new Error(`Invalid JSON in --args: ${e.message}`);
+	}
+	const stdinContent = await readStdin();
+	if (stdinContent) try {
+		const parsed = JSON.parse(stdinContent);
+		if (typeof parsed === "object" && parsed !== null) result = {
+			...result,
+			...parsed
+		};
+	} catch (e) {
+		throw new Error(`Invalid JSON in stdin: ${e.message}`);
+	}
+	const properties = inputSchema?.properties;
+	for (const [key, value] of Object.entries(options)) {
+		const isSchemaProperty = inputSchema?.properties?.[key] !== void 0;
+		if (RESERVED_OPTIONS.has(key) && !isSchemaProperty || value === void 0 || value === null) continue;
+		const propSchema = properties?.[key];
+		result[key] = parseValueBySchema(value, propSchema, key);
+	}
+	return result;
+}
+/**
+* Parse a value according to its JSON Schema type
+*
+* @param value - The value to parse (typically a string from CLI)
+* @param schema - The JSON Schema for this property
+* @param paramName - Parameter name for error messages
+* @returns Parsed value with appropriate type
+*/
+function parseValueBySchema(value, schema, paramName) {
+	if (typeof value !== "string") return value;
+	if (!schema) return value;
+	const schemaType = schema.type;
+	switch (schemaType) {
+		case "integer": {
+			const num = Number(value);
+			if (Number.isNaN(num)) throw new Error(`Invalid integer for '${paramName}': ${value}\nExpected: integer`);
+			return Math.floor(num);
+		}
+		case "number": {
+			const num = Number(value);
+			if (Number.isNaN(num)) throw new Error(`Invalid number for '${paramName}': ${value}\nExpected: number`);
+			return num;
+		}
+		case "boolean":
+			if (value === "true") return true;
+			if (value === "false") return false;
+			throw new Error(`Invalid boolean for '${paramName}': ${value}\nExpected: "true" or "false"`);
+		case "array":
+		case "object": try {
+			return JSON.parse(value);
+		} catch (e) {
+			const errorMsg = e instanceof Error ? e.message : String(e);
+			throw new Error(`Invalid JSON for '${paramName}': ${errorMsg}\nValue: ${value}\nHint: For ${schemaType}s, use valid JSON syntax. ` + (schemaType === "array" ? "Arrays use [...], e.g., '[\"a\",\"b\"]'" : "Objects use {...}, e.g., '{\"key\":\"value\"}'"));
+		}
+		default: return value;
+	}
+}
+/**
+* Convert JSON Schema type to yargs type
+*
+* @param schemaType - JSON Schema type
+* @returns yargs type string
+*/
+function schemaTypeToYargs(schemaType) {
+	switch (schemaType) {
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "array":
+		case "object": return "string";
+		default: return "string";
+	}
+}
+
+//#endregion
+export { RESERVED_OPTIONS, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, schemaTypeToYargs };
+//# sourceMappingURL=exec-args.mjs.map

package/dist/core/helpers/exec-args.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-args.mjs","names":[],"sources":["../../../src/core/helpers/exec-args.ts"],"sourcesContent":["/**\n * exec-args Helpers - Core Implementation\n *\n * Functions for parsing exec command arguments with schema-aware type coercion.\n */\n\nimport type { JSONSchema } from \"../types.js\";\nimport { readStdin } from \"./stdin.js\";\n\n/**\n * Reserved CLI option names that should not be passed as exec arguments\n */\nexport const RESERVED_OPTIONS = new Set([\n  \"json\",\n  \"yaml\",\n  \"view\",\n  \"help\",\n  \"h\",\n  \"version\",\n  \"V\",\n  \"_\", // yargs positional args array\n  \"$0\", // yargs script name\n  \"executable_path\", // positional exec target path (intentionally compound to avoid schema collision)\n  \"executablePath\", // yargs camelCase alias\n  \"args\", // our --args option (processed separately)\n]);\n\n/**\n * Parse exec arguments from CLI options, with optional schema-aware type coercion\n *\n * Priority: CLI flags > stdin > --args\n *\n * @param options - CLI options object\n * @param inputSchema - Optional JSON Schema for type coercion\n * @returns Parsed arguments for exec\n */\nexport function parseExecArgs(\n  options: Record<string, unknown>,\n  inputSchema?: JSONSchema,\n): Record<string, unknown> {\n  let result: Record<string, unknown> = {};\n\n  // Parse --args JSON if provided (lowest priority)\n  if (options.args && typeof options.args === \"string\") {\n    try {\n      const parsed = JSON.parse(options.args);\n      if (typeof parsed === \"object\" && parsed !== null) {\n        result = { ...parsed };\n      }\n    } catch (e) {\n      throw new Error(`Invalid JSON in --args: ${(e as Error).message}`);\n    }\n  }\n\n  // Get properties schema for type coercion\n  const properties = inputSchema?.properties as Record<string, JSONSchema> | undefined;\n\n  // Add named parameters (overwrite JSON args if same key) - highest priority\n  for (const [key, value] of Object.entries(options)) {\n    // Skip reserved options (unless defined in action schema) and undefined/null values\n    const isSchemaProperty = inputSchema?.properties?.[key] !== undefined;\n    if ((RESERVED_OPTIONS.has(key) && !isSchemaProperty) || value === undefined || value === null) {\n      continue;\n    }\n    // Apply schema-aware parsing if schema is available\n    const propSchema = properties?.[key];\n    result[key] = parseValueBySchema(value, propSchema, key);\n  }\n\n  return result;\n}\n\n/**\n * Parse exec arguments with stdin support (async version)\n *\n * Priority: CLI flags > stdin > --args\n *\n * @param options - CLI options object from yargs\n * @param inputSchema - Optional JSON Schema for type-aware coercion\n * @returns Parsed arguments for exec\n */\nexport async function parseExecArgsWithStdin(\n  options: Record<string, unknown>,\n  inputSchema?: JSONSchema,\n): Promise<Record<string, unknown>> {\n  let result: Record<string, unknown> = {};\n\n  // 1. Parse --args JSON if provided (lowest priority)\n  if (options.args && typeof options.args === \"string\") {\n    try {\n      const parsed = JSON.parse(options.args);\n      if (typeof parsed === \"object\" && parsed !== null) {\n        result = { ...parsed };\n      }\n    } catch (e) {\n      throw new Error(`Invalid JSON in --args: ${(e as Error).message}`);\n    }\n  }\n\n  // 2. Read from stdin if available (medium priority)\n  const stdinContent = await readStdin();\n  if (stdinContent) {\n    try {\n      const parsed = JSON.parse(stdinContent);\n      if (typeof parsed === \"object\" && parsed !== null) {\n        result = { ...result, ...parsed };\n      }\n    } catch (e) {\n      throw new Error(`Invalid JSON in stdin: ${(e as Error).message}`);\n    }\n  }\n\n  // Get properties schema for type coercion\n  const properties = inputSchema?.properties as Record<string, JSONSchema> | undefined;\n\n  // 3. Add named CLI parameters (highest priority) with schema-aware parsing\n  for (const [key, value] of Object.entries(options)) {\n    // Skip reserved options (unless defined in action schema) and undefined/null values\n    const isSchemaProperty = inputSchema?.properties?.[key] !== undefined;\n    if ((RESERVED_OPTIONS.has(key) && !isSchemaProperty) || value === undefined || value === null) {\n      continue;\n    }\n    // Apply schema-aware parsing if schema is available\n    const propSchema = properties?.[key];\n    result[key] = parseValueBySchema(value, propSchema, key);\n  }\n\n  return result;\n}\n\n/**\n * Parse a value according to its JSON Schema type\n *\n * @param value - The value to parse (typically a string from CLI)\n * @param schema - The JSON Schema for this property\n * @param paramName - Parameter name for error messages\n * @returns Parsed value with appropriate type\n */\nexport function parseValueBySchema(\n  value: unknown,\n  schema: JSONSchema | undefined,\n  paramName: string,\n): unknown {\n  // If value is not a string, return as-is (already parsed by yargs or --args)\n  if (typeof value !== \"string\") {\n    return value;\n  }\n\n  // If no schema, return string as-is\n  if (!schema) {\n    return value;\n  }\n\n  const schemaType = schema.type;\n\n  switch (schemaType) {\n    case \"integer\": {\n      const num = Number(value);\n      if (Number.isNaN(num)) {\n        throw new Error(`Invalid integer for '${paramName}': ${value}\\nExpected: integer`);\n      }\n      return Math.floor(num);\n    }\n\n    case \"number\": {\n      const num = Number(value);\n      if (Number.isNaN(num)) {\n        throw new Error(`Invalid number for '${paramName}': ${value}\\nExpected: number`);\n      }\n      return num;\n    }\n\n    case \"boolean\": {\n      if (value === \"true\") return true;\n      if (value === \"false\") return false;\n      throw new Error(`Invalid boolean for '${paramName}': ${value}\\nExpected: \"true\" or \"false\"`);\n    }\n\n    case \"array\":\n    case \"object\": {\n      try {\n        return JSON.parse(value);\n      } catch (e) {\n        const errorMsg = e instanceof Error ? e.message : String(e);\n        throw new Error(\n          `Invalid JSON for '${paramName}': ${errorMsg}\\n` +\n            `Value: ${value}\\n` +\n            `Hint: For ${schemaType}s, use valid JSON syntax. ` +\n            (schemaType === \"array\"\n              ? 'Arrays use [...], e.g., \\'[\"a\",\"b\"]\\''\n              : 'Objects use {...}, e.g., \\'{\"key\":\"value\"}\\''),\n        );\n      }\n    }\n\n    default:\n      // string or unknown type: return as-is\n      return value;\n  }\n}\n\n/**\n * Convert JSON Schema type to yargs type\n *\n * @param schemaType - JSON Schema type\n * @returns yargs type string\n */\nexport function schemaTypeToYargs(\n  schemaType: JSONSchema[\"type\"],\n): \"string\" | \"number\" | \"boolean\" | \"array\" {\n  switch (schemaType) {\n    case \"integer\":\n    case \"number\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"array\":\n    case \"object\":\n      // Use \"string\" so yargs passes raw JSON string to parseValueBySchema for parsing\n      return \"string\";\n    default:\n      return \"string\";\n  }\n}\n"],"mappings":"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"}

package/dist/core/helpers/stdin.cjs

@@ -0,0 +1,41 @@
+
+//#region src/core/helpers/stdin.ts
+/**
+* stdin Helpers - Core Implementation
+*
+* Functions for reading from stdin in a non-blocking way.
+*/
+/**
+* Read content from stdin (non-blocking if TTY or no data available)
+*
+* @returns The stdin content, or null if no data available
+*/
+async function readStdin() {
+	if (process.stdin.isTTY) return null;
+	if (!await new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			process.stdin.removeAllListeners("readable");
+			resolve(false);
+		}, 100);
+		process.stdin.once("readable", () => {
+			clearTimeout(timeout);
+			resolve(true);
+		});
+		process.stdin.once("end", () => {
+			clearTimeout(timeout);
+			resolve(false);
+		});
+		if (process.stdin.readableLength > 0) {
+			clearTimeout(timeout);
+			process.stdin.removeAllListeners("readable");
+			process.stdin.removeAllListeners("end");
+			resolve(true);
+		}
+	})) return null;
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf-8").trim() || null;
+}
+
+//#endregion
+exports.readStdin = readStdin;

package/dist/core/helpers/stdin.d.cts

@@ -0,0 +1,15 @@
+//#region src/core/helpers/stdin.d.ts
+/**
+ * stdin Helpers - Core Implementation
+ *
+ * Functions for reading from stdin in a non-blocking way.
+ */
+/**
+ * Read content from stdin (non-blocking if TTY or no data available)
+ *
+ * @returns The stdin content, or null if no data available
+ */
+declare function readStdin(): Promise<string | null>;
+//#endregion
+export { readStdin };
+//# sourceMappingURL=stdin.d.cts.map

package/dist/core/helpers/stdin.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin.d.cts","names":[],"sources":["../../../src/core/helpers/stdin.ts"],"mappings":";;AAWA;;;;;;;;;iBAAsB,SAAA,CAAA,GAAa,OAAA"}

package/dist/core/helpers/stdin.d.mts

@@ -0,0 +1,15 @@
+//#region src/core/helpers/stdin.d.ts
+/**
+ * stdin Helpers - Core Implementation
+ *
+ * Functions for reading from stdin in a non-blocking way.
+ */
+/**
+ * Read content from stdin (non-blocking if TTY or no data available)
+ *
+ * @returns The stdin content, or null if no data available
+ */
+declare function readStdin(): Promise<string | null>;
+//#endregion
+export { readStdin };
+//# sourceMappingURL=stdin.d.mts.map

package/dist/core/helpers/stdin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin.d.mts","names":[],"sources":["../../../src/core/helpers/stdin.ts"],"mappings":";;AAWA;;;;;;;;;iBAAsB,SAAA,CAAA,GAAa,OAAA"}

package/dist/core/helpers/stdin.mjs

@@ -0,0 +1,41 @@
+//#region src/core/helpers/stdin.ts
+/**
+* stdin Helpers - Core Implementation
+*
+* Functions for reading from stdin in a non-blocking way.
+*/
+/**
+* Read content from stdin (non-blocking if TTY or no data available)
+*
+* @returns The stdin content, or null if no data available
+*/
+async function readStdin() {
+	if (process.stdin.isTTY) return null;
+	if (!await new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			process.stdin.removeAllListeners("readable");
+			resolve(false);
+		}, 100);
+		process.stdin.once("readable", () => {
+			clearTimeout(timeout);
+			resolve(true);
+		});
+		process.stdin.once("end", () => {
+			clearTimeout(timeout);
+			resolve(false);
+		});
+		if (process.stdin.readableLength > 0) {
+			clearTimeout(timeout);
+			process.stdin.removeAllListeners("readable");
+			process.stdin.removeAllListeners("end");
+			resolve(true);
+		}
+	})) return null;
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf-8").trim() || null;
+}
+
+//#endregion
+export { readStdin };
+//# sourceMappingURL=stdin.mjs.map

package/dist/core/helpers/stdin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin.mjs","names":[],"sources":["../../../src/core/helpers/stdin.ts"],"sourcesContent":["/**\n * stdin Helpers - Core Implementation\n *\n * Functions for reading from stdin in a non-blocking way.\n */\n\n/**\n * Read content from stdin (non-blocking if TTY or no data available)\n *\n * @returns The stdin content, or null if no data available\n */\nexport async function readStdin(): Promise<string | null> {\n  // Only read from stdin if it's not a TTY (i.e., there's pipe input)\n  if (process.stdin.isTTY) {\n    return null;\n  }\n\n  // Check if stdin has data available using a short timeout\n  // This prevents hanging when stdin is connected but empty (e.g., through timeout command)\n  const hasData = await new Promise<boolean>((resolve) => {\n    // Use setImmediate to check if stdin has data on the next event loop tick\n    const timeout = setTimeout(() => {\n      process.stdin.removeAllListeners(\"readable\");\n      resolve(false);\n    }, 100); // 100ms timeout to check for data\n\n    process.stdin.once(\"readable\", () => {\n      clearTimeout(timeout);\n      resolve(true);\n    });\n\n    // Also check if stdin is already ended\n    process.stdin.once(\"end\", () => {\n      clearTimeout(timeout);\n      resolve(false);\n    });\n\n    // Check if there's already data in the buffer\n    if (process.stdin.readableLength > 0) {\n      clearTimeout(timeout);\n      process.stdin.removeAllListeners(\"readable\");\n      process.stdin.removeAllListeners(\"end\");\n      resolve(true);\n    }\n  });\n\n  if (!hasData) {\n    return null;\n  }\n\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) {\n    chunks.push(chunk as Buffer);\n  }\n  const content = Buffer.concat(chunks).toString(\"utf-8\").trim();\n  return content || null;\n}\n"],"mappings":";;;;;;;;;;;AAWA,eAAsB,YAAoC;AAExD,KAAI,QAAQ,MAAM,MAChB,QAAO;AAgCT,KAAI,CA3BY,MAAM,IAAI,SAAkB,YAAY;EAEtD,MAAM,UAAU,iBAAiB;AAC/B,WAAQ,MAAM,mBAAmB,WAAW;AAC5C,WAAQ,MAAM;KACb,IAAI;AAEP,UAAQ,MAAM,KAAK,kBAAkB;AACnC,gBAAa,QAAQ;AACrB,WAAQ,KAAK;IACb;AAGF,UAAQ,MAAM,KAAK,aAAa;AAC9B,gBAAa,QAAQ;AACrB,WAAQ,MAAM;IACd;AAGF,MAAI,QAAQ,MAAM,iBAAiB,GAAG;AACpC,gBAAa,QAAQ;AACrB,WAAQ,MAAM,mBAAmB,WAAW;AAC5C,WAAQ,MAAM,mBAAmB,MAAM;AACvC,WAAQ,KAAK;;GAEf,CAGA,QAAO;CAGT,MAAM,SAAmB,EAAE;AAC3B,YAAW,MAAM,SAAS,QAAQ,MAChC,QAAO,KAAK,MAAgB;AAG9B,QADgB,OAAO,OAAO,OAAO,CAAC,SAAS,QAAQ,CAAC,MAAM,IAC5C"}

package/dist/core/index.cjs

@@ -0,0 +1,49 @@
+const require_delete = require('./formatters/delete.cjs');
+const require_exec = require('./formatters/exec.cjs');
+const require_explain = require('./formatters/explain.cjs');
+const require_ls = require('./formatters/ls.cjs');
+const require_mount = require('./formatters/mount.cjs');
+const require_read = require('./formatters/read.cjs');
+const require_stat = require('./formatters/stat.cjs');
+const require_write = require('./formatters/write.cjs');
+const require_path_utils = require('../path-utils.cjs');
+require('./path-utils.cjs');
+const require_delete$1 = require('./commands/delete.cjs');
+const require_stdin = require('./helpers/stdin.cjs');
+const require_exec_args = require('./helpers/exec-args.cjs');
+const require_exec$1 = require('./commands/exec.cjs');
+const require_explain$1 = require('./commands/explain.cjs');
+const require_ls$1 = require('./commands/ls.cjs');
+const require_mount$1 = require('./commands/mount.cjs');
+const require_read$1 = require('./commands/read.cjs');
+const require_stat$1 = require('./commands/stat.cjs');
+const require_write$1 = require('./commands/write.cjs');
+const require_index = require('./commands/index.cjs');
+const require_index$1 = require('./executor/index.cjs');
+
+exports.AFSCommandExecutor = require_index$1.AFSCommandExecutor;
+exports.RESERVED_OPTIONS = require_exec_args.RESERVED_OPTIONS;
+exports.cliPathToCanonical = require_path_utils.cliPathToCanonical;
+exports.commandFactories = require_index.commandFactories;
+exports.createDeleteCommand = require_delete$1.createDeleteCommand;
+exports.createExecCommand = require_exec$1.createExecCommand;
+exports.createExplainCommand = require_explain$1.createExplainCommand;
+exports.createLsCommand = require_ls$1.createLsCommand;
+exports.createMountCommand = require_mount$1.createMountCommand;
+exports.createReadCommand = require_read$1.createReadCommand;
+exports.createStatCommand = require_stat$1.createStatCommand;
+exports.createWriteCommand = require_write$1.createWriteCommand;
+exports.formatDeleteOutput = require_delete.formatDeleteOutput;
+exports.formatExecOutput = require_exec.formatExecOutput;
+exports.formatExplainOutput = require_explain.formatExplainOutput;
+exports.formatLsOutput = require_ls.formatLsOutput;
+exports.formatMountListOutput = require_mount.formatMountListOutput;
+exports.formatReadOutput = require_read.formatReadOutput;
+exports.formatStatOutput = require_stat.formatStatOutput;
+exports.formatWriteOutput = require_write.formatWriteOutput;
+exports.parseCliPath = require_path_utils.parseCliPath;
+exports.parseExecArgs = require_exec_args.parseExecArgs;
+exports.parseExecArgsWithStdin = require_exec_args.parseExecArgsWithStdin;
+exports.parseValueBySchema = require_exec_args.parseValueBySchema;
+exports.readStdin = require_stdin.readStdin;
+exports.schemaTypeToYargs = require_exec_args.schemaTypeToYargs;

package/dist/core/index.d.cts

@@ -0,0 +1,24 @@
+import { JSONSchema, ViewType } from "./types.cjs";
+import { CommandFactory, CommandFactoryOptions, CommandOutput, FormatFunction } from "./commands/types.cjs";
+import { DeleteArgs, createDeleteCommand } from "./commands/delete.cjs";
+import { RESERVED_OPTIONS, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, schemaTypeToYargs } from "./helpers/exec-args.cjs";
+import { ExecArgs, createExecCommand } from "./commands/exec.cjs";
+import { ExplainArgs, createExplainCommand } from "./commands/explain.cjs";
+import { LsArgs, createLsCommand } from "./commands/ls.cjs";
+import { MountAddArgs, MountListArgs, MountRemoveArgs, createMountCommand } from "./commands/mount.cjs";
+import { ReadArgs, createReadCommand } from "./commands/read.cjs";
+import { StatArgs, createStatCommand } from "./commands/stat.cjs";
+import { WriteArgs, createWriteCommand } from "./commands/write.cjs";
+import { commandFactories } from "./commands/index.cjs";
+import { AFSCommandExecutor, ExecuteResult, ExecutorOptions } from "./executor/index.cjs";
+import { formatDeleteOutput } from "./formatters/delete.cjs";
+import { formatExecOutput } from "./formatters/exec.cjs";
+import { formatExplainOutput } from "./formatters/explain.cjs";
+import { FormatLsOptions, formatLsOutput } from "./formatters/ls.cjs";
+import { formatMountListOutput } from "./formatters/mount.cjs";
+import { formatReadOutput } from "./formatters/read.cjs";
+import { formatStatOutput } from "./formatters/stat.cjs";
+import { formatWriteOutput } from "./formatters/write.cjs";
+import { readStdin } from "./helpers/stdin.cjs";
+import { ParsedCliPath, cliPathToCanonical, parseCliPath } from "../path-utils.cjs";
+export { AFSCommandExecutor, type CommandFactory, type CommandFactoryOptions, type CommandOutput, type DeleteArgs, type ExecArgs, type ExecuteResult, type ExecutorOptions, type ExplainArgs, type FormatFunction, type FormatLsOptions, type JSONSchema, type LsArgs, type MountAddArgs, type MountListArgs, type MountRemoveArgs, type ParsedCliPath, RESERVED_OPTIONS, type ReadArgs, type StatArgs, type ViewType, type WriteArgs, cliPathToCanonical, commandFactories, createDeleteCommand, createExecCommand, createExplainCommand, createLsCommand, createMountCommand, createReadCommand, createStatCommand, createWriteCommand, formatDeleteOutput, formatExecOutput, formatExplainOutput, formatLsOutput, formatMountListOutput, formatReadOutput, formatStatOutput, formatWriteOutput, parseCliPath, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, readStdin, schemaTypeToYargs };

package/dist/core/index.d.mts

@@ -0,0 +1,25 @@
+import { JSONSchema, ViewType } from "./types.mjs";
+import { CommandFactory, CommandFactoryOptions, CommandOutput, FormatFunction } from "./commands/types.mjs";
+import { DeleteArgs, createDeleteCommand } from "./commands/delete.mjs";
+import { RESERVED_OPTIONS, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, schemaTypeToYargs } from "./helpers/exec-args.mjs";
+import { ExecArgs, createExecCommand } from "./commands/exec.mjs";
+import { ExplainArgs, createExplainCommand } from "./commands/explain.mjs";
+import { LsArgs, createLsCommand } from "./commands/ls.mjs";
+import { MountAddArgs, MountListArgs, MountRemoveArgs, createMountCommand } from "./commands/mount.mjs";
+import { ReadArgs, createReadCommand } from "./commands/read.mjs";
+import { StatArgs, createStatCommand } from "./commands/stat.mjs";
+import { WriteArgs, createWriteCommand } from "./commands/write.mjs";
+import { commandFactories } from "./commands/index.mjs";
+import { AFSCommandExecutor, ExecuteResult, ExecutorOptions } from "./executor/index.mjs";
+import { formatDeleteOutput } from "./formatters/delete.mjs";
+import { formatExecOutput } from "./formatters/exec.mjs";
+import { formatExplainOutput } from "./formatters/explain.mjs";
+import { FormatLsOptions, formatLsOutput } from "./formatters/ls.mjs";
+import { formatMountListOutput } from "./formatters/mount.mjs";
+import { formatReadOutput } from "./formatters/read.mjs";
+import { formatStatOutput } from "./formatters/stat.mjs";
+import { formatWriteOutput } from "./formatters/write.mjs";
+import "./formatters/index.mjs";
+import { readStdin } from "./helpers/stdin.mjs";
+import { ParsedCliPath, cliPathToCanonical, parseCliPath } from "../path-utils.mjs";
+export { AFSCommandExecutor, type CommandFactory, type CommandFactoryOptions, type CommandOutput, type DeleteArgs, type ExecArgs, type ExecuteResult, type ExecutorOptions, type ExplainArgs, type FormatFunction, type FormatLsOptions, type JSONSchema, type LsArgs, type MountAddArgs, type MountListArgs, type MountRemoveArgs, type ParsedCliPath, RESERVED_OPTIONS, type ReadArgs, type StatArgs, type ViewType, type WriteArgs, cliPathToCanonical, commandFactories, createDeleteCommand, createExecCommand, createExplainCommand, createLsCommand, createMountCommand, createReadCommand, createStatCommand, createWriteCommand, formatDeleteOutput, formatExecOutput, formatExplainOutput, formatLsOutput, formatMountListOutput, formatReadOutput, formatStatOutput, formatWriteOutput, parseCliPath, parseExecArgs, parseExecArgsWithStdin, parseValueBySchema, readStdin, schemaTypeToYargs };