@aigne/cli 1.74.0-beta.1 → 1.74.0-beta.2

package/dist/shell/repl.cjs

@@ -0,0 +1,544 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_aigne_hub_model = require('../utils/aigne-hub/model.cjs');
+const require_terminal_input = require('../ui/utils/terminal-input.cjs');
+const require_terminal = require('../tracer/terminal.cjs');
+let chalk = require("chalk");
+chalk = require_rolldown_runtime.__toESM(chalk);
+let node_path = require("node:path");
+let _aigne_core = require("@aigne/core");
+let _aigne_core_loader = require("@aigne/core/loader");
+
+//#region src/shell/repl.ts
+/**
+* Get the prompt string based on current shell state
+*/
+function getPrompt(state) {
+	if (state.config?.prompt) return state.config.prompt.replace("{mode}", state.mode).replace("{agent}", state.agent?.name || "");
+	if (state.mode === "agent" && state.agent?.name) return `aigne [${state.agent.name}]>`;
+	return "aigne>";
+}
+/**
+* Create or recreate UserAgent for the current agent
+* Call this when agent changes or when clearing conversation
+*/
+function resetUserAgent(state) {
+	state.userAgent = state.aigne.invoke(state.agent);
+}
+/**
+* Helper to resolve path
+*/
+function resolvePath(path) {
+	return (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(process.cwd(), path);
+}
+/**
+* /load command - Load an agent from a path
+*/
+async function handleLoad(args, state) {
+	if (args.length === 0) return { message: `${chalk.default.red("Error:")} No path specified.\nUsage: /load <path>` };
+	const path = resolvePath(args[0]);
+	try {
+		const agent = await (0, _aigne_core_loader.loadAgent)(path, { model: (modelOptions) => require_utils_aigne_hub_model.loadChatModel({ ...modelOptions }) });
+		const name = agent.name || args[0] || "unnamed";
+		state.loadedAgents.set(name, {
+			agent,
+			path
+		});
+		state.agent = agent;
+		state.mode = "agent";
+		resetUserAgent(state);
+		return { message: chalk.default.green(`Loaded: ${name}`) };
+	} catch (error) {
+		return { message: `${chalk.default.red("Error:")} Failed to load agent from ${path}\n${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+/**
+* /list command - List all loaded agents
+*/
+function handleList(_args, state) {
+	if (state.loadedAgents.size === 0) return { message: chalk.default.gray("No agents loaded. Use /load <path> to load an agent.") };
+	const lines = ["Loaded agents:"];
+	for (const [name, { path }] of state.loadedAgents) {
+		const prefix = state.mode === "agent" && state.agent?.name === name ? chalk.default.green("* ") : "  ";
+		lines.push(`${prefix}${name} ${chalk.default.gray(`(${path})`)}`);
+	}
+	return { message: lines.join("\n") };
+}
+/**
+* /switch command - Switch to a different loaded agent
+*/
+function handleSwitch(args, state) {
+	if (state.loadedAgents.size === 0) return { message: chalk.default.gray("No agents loaded. Use /load <path> to load an agent first.") };
+	const name = args[0];
+	if (!name) {
+		const lines = ["Available agents:"];
+		let i = 1;
+		for (const [agentName] of state.loadedAgents) {
+			lines.push(`  ${i}. ${agentName}`);
+			i++;
+		}
+		lines.push("\nUsage: /switch <name>");
+		return { message: lines.join("\n") };
+	}
+	const loaded = state.loadedAgents.get(name);
+	if (!loaded) return { message: `${chalk.default.red("Agent not found:")} ${name}` };
+	state.agent = loaded.agent;
+	state.mode = "agent";
+	resetUserAgent(state);
+	return { message: chalk.default.green(`Switched to: ${name}`) };
+}
+/**
+* /unload command - Unload an agent
+*/
+function handleUnload(args, state) {
+	if (state.loadedAgents.size === 0) return { message: chalk.default.gray("No agents loaded.") };
+	const name = args[0];
+	if (!name) return { message: `${chalk.default.red("Error:")} No agent name specified.\nUsage: /unload <name>` };
+	if (!state.loadedAgents.has(name)) return { message: `${chalk.default.red("Agent not found:")} ${name}` };
+	const isCurrentAgent = state.mode === "agent" && state.agent?.name === name;
+	state.loadedAgents.delete(name);
+	if (isCurrentAgent) {
+		const remaining = state.loadedAgents.values().next();
+		if (!remaining.done && remaining.value) state.agent = remaining.value.agent;
+		else {
+			state.agent = state.defaultAgent;
+			state.mode = "direct";
+		}
+		resetUserAgent(state);
+	}
+	return { message: chalk.default.green(`Unloaded: ${name}`) };
+}
+/**
+* /info command - Show current agent info
+*/
+function handleInfo(_args, state) {
+	const lines = [];
+	lines.push(`${chalk.default.cyan("Current Mode:")} ${state.mode}`);
+	if (state.mode === "agent" && state.agent) {
+		lines.push(`${chalk.default.cyan("Agent:")} ${state.agent.name || "unnamed"}`);
+		if (state.agent instanceof _aigne_core.AIAgent && state.agent.instructions) {
+			const instructions = typeof state.agent.instructions === "string" ? state.agent.instructions : "function-based instructions";
+			lines.push(`${chalk.default.cyan("Instructions:")} ${instructions.slice(0, 100)}...`);
+		}
+	} else lines.push(`${chalk.default.cyan("Agent:")} default assistant (direct mode)`);
+	lines.push(`${chalk.default.cyan("Loaded Agents:")} ${state.loadedAgents.size}`);
+	return { message: lines.join("\n") };
+}
+/**
+* /mode command - Display or switch mode
+*/
+function handleMode(args, state) {
+	if (args.length === 0) return { message: `${chalk.default.cyan("Current mode:")} ${state.mode}\n\nAvailable modes:\n  direct - Direct LLM conversation\n  agent  - Conversation through loaded agent` };
+	const targetMode = args[0]?.toLowerCase();
+	if (targetMode === "direct") {
+		state.mode = "direct";
+		state.agent = state.defaultAgent;
+		resetUserAgent(state);
+		return { message: chalk.default.green("Switched to direct mode.") };
+	}
+	if (targetMode === "agent") {
+		if (state.loadedAgents.size === 0) return { message: `${chalk.default.red("Error:")} No agents loaded. Use /load <path> first.` };
+		if (state.mode === "agent" && state.agent !== state.defaultAgent) return { message: chalk.default.gray("Already in agent mode.") };
+		const firstAgent = state.loadedAgents.values().next().value;
+		if (firstAgent) {
+			state.agent = firstAgent.agent;
+			state.mode = "agent";
+			resetUserAgent(state);
+			return { message: chalk.default.green(`Switched to agent mode with: ${firstAgent.agent.name}`) };
+		}
+		return { message: `${chalk.default.red("Error:")} No agents loaded.` };
+	}
+	return { message: `${chalk.default.red("Error:")} Unknown mode: ${targetMode}\nAvailable modes: direct, agent` };
+}
+/**
+* /run command - Run an agent from a path (single execution)
+*/
+async function handleRun(args, state) {
+	if (args.length === 0) return { message: `${chalk.default.red("Error:")} No path specified.\nUsage: /run <path> [input]` };
+	const path = resolvePath(args[0]);
+	const input = args.slice(1).join(" ");
+	try {
+		const agent = await (0, _aigne_core_loader.loadAgent)(path, { model: (modelOptions) => require_utils_aigne_hub_model.loadChatModel({ ...modelOptions }) });
+		const { aigne } = state;
+		const tracer = new require_terminal.TerminalTracer(aigne.newContext(), {});
+		const message = input ? { message: input } : {};
+		await tracer.run(agent, message);
+		return {};
+	} catch (error) {
+		return { message: `${chalk.default.red("Error:")} Failed to run agent from ${path}\n${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+/**
+* /eval command - Placeholder for agent evaluation
+*/
+function handleEval(args, _state) {
+	if (args.length === 0) return { message: `${chalk.default.red("Error:")} Missing arguments.\nUsage: /eval <agent> --dataset <path>\n\nFor full evaluation, use: aigne eval <path> --agent <name> --dataset <path>` };
+	return { message: `${chalk.default.yellow("Note:")} Full evaluation is better done via CLI.\nRun: ${chalk.default.cyan("aigne eval")} ${args.join(" ")}` };
+}
+/**
+* CLI command documentation for /explain
+*/
+const CLI_COMMAND_DOCS = {
+	run: {
+		purpose: "Run an AIGNE agent from a directory or URL",
+		usage: "aigne run [path] [--input <message>] [--model <model>] [--interactive] [--json]",
+		examples: [
+			"aigne run ./my-agent",
+			"aigne run ./my-agent --input 'Hello'",
+			"aigne run ./my-agent --interactive"
+		]
+	},
+	eval: {
+		purpose: "Evaluate an AIGNE agent against test cases",
+		usage: "aigne eval [path] --agent <name> --dataset <path> [--output <path>]",
+		examples: ["aigne eval . --agent my-agent --dataset tests.json", "aigne eval . --agent my-agent --dataset tests.json --output results.csv"]
+	},
+	skill: {
+		purpose: "Run Agent Skills from specified directories",
+		usage: "aigne skill <paths..> [--input <message>] [--interactive]",
+		examples: ["aigne skill ./skill1 ./skill2", "aigne skill ./my-skill --interactive"]
+	},
+	test: {
+		purpose: "Run agent tests in the specified directory",
+		usage: "aigne test [--filter <pattern>] [--json]",
+		examples: ["aigne test", "aigne test --filter 'my-test'"]
+	},
+	create: {
+		purpose: "Create a new AIGNE agent project",
+		usage: "aigne create [path] [--template <name>]",
+		examples: ["aigne create my-agent", "aigne create my-agent --template chatbot"]
+	},
+	"serve-mcp": {
+		purpose: "Serve agents as an MCP (Model Context Protocol) server",
+		usage: "aigne serve-mcp [path] [--host <host>] [--port <port>]",
+		examples: ["aigne serve-mcp .", "aigne serve-mcp ./my-agent --port 8080"]
+	},
+	hub: {
+		purpose: "Manage AIGNE Hub connections",
+		usage: "aigne hub <command>",
+		examples: [
+			"aigne hub list",
+			"aigne hub connect",
+			"aigne hub status"
+		]
+	},
+	shell: {
+		purpose: "Start an interactive shell for LLM conversation",
+		usage: "aigne shell [--model <model>]",
+		examples: ["aigne shell", "aigne shell --model gpt-4"]
+	}
+};
+/**
+* /explain command - Show CLI command documentation
+*/
+function handleExplain(args, _state) {
+	if (args.length === 0) {
+		const lines$1 = [chalk.default.bold("Available commands:")];
+		for (const [name, doc$1] of Object.entries(CLI_COMMAND_DOCS)) lines$1.push(`  ${chalk.default.cyan(name.padEnd(12))} ${doc$1.purpose}`);
+		lines$1.push("");
+		lines$1.push("Use /explain <command> for detailed documentation.");
+		return { message: lines$1.join("\n") };
+	}
+	const cmdName = args[0]?.toLowerCase();
+	const doc = CLI_COMMAND_DOCS[cmdName];
+	if (!doc) return { message: `${chalk.default.red("Error:")} unknown command: ${cmdName}\n\nAvailable commands: ${Object.keys(CLI_COMMAND_DOCS).join(", ")}` };
+	const lines = [
+		`${chalk.default.bold("COMMAND")} aigne ${cmdName}`,
+		"",
+		chalk.default.bold("PURPOSE"),
+		`  ${doc.purpose}`,
+		"",
+		chalk.default.bold("USAGE"),
+		`  ${doc.usage}`
+	];
+	if (doc.examples?.length) {
+		lines.push("", chalk.default.bold("EXAMPLES"));
+		for (const ex of doc.examples) lines.push(`  ${chalk.default.gray("$")} ${ex}`);
+	}
+	return { message: lines.join("\n") };
+}
+/**
+* /sessions command - List available sessions
+*/
+function handleSessions(_args, state) {
+	if (!state.sessionId) return { message: chalk.default.yellow("Session history not configured. Start shell with history enabled to use this feature.") };
+	return { message: [
+		chalk.default.bold("Current Session:"),
+		`  ${chalk.default.cyan("ID:")} ${state.sessionId}`,
+		"",
+		chalk.default.gray("Note: Full session listing requires AFS History provider.")
+	].join("\n") };
+}
+/**
+* /history command - Show conversation history
+*/
+function handleHistory(args, state) {
+	if (!state.sessionId) return { message: chalk.default.yellow("Session history not configured. Start shell with history enabled to use this feature.") };
+	const count = args[0] ? Number.parseInt(args[0], 10) : 10;
+	if (Number.isNaN(count)) return { message: `${chalk.default.red("Error:")} Invalid count: ${args[0]}\nUsage: /history [count]` };
+	return { message: chalk.default.gray(`Showing last ${count} messages (feature requires AFS History).`) };
+}
+/**
+* /restore command - Restore a previous session
+*/
+function handleRestore(args, state) {
+	if (args.length === 0) return { message: `${chalk.default.red("Error:")} No session ID specified.\nUsage: /restore <sessionId>` };
+	if (!state.sessionId) return { message: chalk.default.yellow("Session history not configured. Cannot restore sessions without history provider.") };
+	const sessionId = args[0];
+	return { message: chalk.default.yellow(`Session restore not yet implemented. Requested session: ${sessionId}`) };
+}
+/**
+* /export command - Export conversation
+*/
+function handleExport(args, state) {
+	const format = args[0] || "json";
+	const path = args[1];
+	if (!state.sessionId) return { message: chalk.default.yellow("Session history not configured. Nothing to export.") };
+	return { message: [
+		chalk.default.bold("Export Options:"),
+		`  Format: ${format} (json, markdown, text)`,
+		`  Path: ${path || "(stdout)"}`,
+		"",
+		"Usage: /export [format] [path]"
+	].join("\n") };
+}
+/**
+* /clear command - Clear conversation history
+*/
+function handleClear(_args, state) {
+	if (state.sessionId) state.sessionId = crypto.randomUUID();
+	resetUserAgent(state);
+	return { message: chalk.default.green("Conversation cleared.") };
+}
+/**
+* /model command - Display or change model
+*/
+async function handleModel(args, state) {
+	const { aigne } = state;
+	if (args.length === 0) {
+		const model = aigne.model;
+		if (!model) return { message: chalk.default.yellow("No model configured.") };
+		try {
+			const credential = await model.credential;
+			const modelName = credential?.model || "default";
+			const lines = [chalk.default.bold("Current Model:"), `  ${chalk.default.cyan("Model:")} ${modelName}`];
+			if (credential?.apiKey) {
+				const masked = `${credential.apiKey.slice(0, 4)}...${credential.apiKey.slice(-4)}`;
+				lines.push(`  ${chalk.default.cyan("API Key:")} ${masked}`);
+			}
+			return { message: lines.join("\n") };
+		} catch {
+			return { message: `${chalk.default.cyan("Model:")} configured (details unavailable)` };
+		}
+	}
+	return { message: chalk.default.yellow("Changing model at runtime is not yet supported.\nRestart shell with: aigne shell --model " + args[0]) };
+}
+/**
+* Help command categories with their commands
+*/
+const HELP_CATEGORIES = [
+	{
+		name: "Commands",
+		commands: [{
+			cmd: "/help",
+			desc: "Show this help message"
+		}, {
+			cmd: "/exit",
+			desc: "Exit the shell",
+			alias: "/quit"
+		}]
+	},
+	{
+		name: "Agent Operations",
+		commands: [
+			{
+				cmd: "/load <path>",
+				desc: "Load an agent from a path"
+			},
+			{
+				cmd: "/list",
+				desc: "List loaded agents"
+			},
+			{
+				cmd: "/switch <name>",
+				desc: "Switch to a different agent"
+			},
+			{
+				cmd: "/unload <name>",
+				desc: "Unload an agent"
+			},
+			{
+				cmd: "/info",
+				desc: "Show current agent info"
+			}
+		]
+	},
+	{
+		name: "Mode",
+		commands: [
+			{
+				cmd: "/mode",
+				desc: "Show current mode"
+			},
+			{
+				cmd: "/mode direct",
+				desc: "Switch to direct LLM mode"
+			},
+			{
+				cmd: "/mode agent",
+				desc: "Switch to agent mode"
+			}
+		]
+	},
+	{
+		name: "CLI Bridge",
+		commands: [
+			{
+				cmd: "/run <path>",
+				desc: "Run an agent (single execution)"
+			},
+			{
+				cmd: "/eval <path>",
+				desc: "Evaluate an agent"
+			},
+			{
+				cmd: "/explain <cmd>",
+				desc: "Explain CLI command"
+			}
+		]
+	},
+	{
+		name: "Session",
+		commands: [
+			{
+				cmd: "/sessions",
+				desc: "List available sessions"
+			},
+			{
+				cmd: "/history [n]",
+				desc: "Show conversation history"
+			},
+			{
+				cmd: "/restore <id>",
+				desc: "Restore a previous session"
+			},
+			{
+				cmd: "/export",
+				desc: "Export conversation"
+			},
+			{
+				cmd: "/clear",
+				desc: "Clear conversation"
+			}
+		]
+	},
+	{
+		name: "Settings",
+		commands: [{
+			cmd: "/model",
+			desc: "Show current model info"
+		}]
+	}
+];
+/**
+* Generate help message based on state config
+*/
+function generateHelp(state) {
+	const hiddenCommands = new Set(state.config?.commands?.hide || []);
+	const lines = [];
+	for (const category of HELP_CATEGORIES) {
+		const visibleCommands = category.commands.filter((c) => {
+			const baseCmd = c.cmd.split(" ")[0];
+			return !hiddenCommands.has(baseCmd);
+		});
+		if (visibleCommands.length === 0) continue;
+		lines.push(chalk.default.bold(`${category.name}:`));
+		for (const c of visibleCommands) {
+			const alias = c.alias ? ` ${chalk.default.gray(`(or ${c.alias})`)}` : "";
+			lines.push(`  ${chalk.default.cyan(c.cmd.padEnd(18))}${alias} ${c.desc}`);
+		}
+		lines.push("");
+	}
+	lines.push(chalk.default.bold("Tips:"));
+	lines.push("  - Type your message and press Enter to chat");
+	lines.push("  - Press Ctrl+C to cancel current input");
+	lines.push("  - Press Ctrl+D to exit");
+	return lines.join("\n").trim();
+}
+const SLASH_COMMANDS = {
+	"/exit": () => ({ exit: true }),
+	"/quit": () => ({ exit: true }),
+	"/help": (_args, state) => ({ message: generateHelp(state) }),
+	"/load": handleLoad,
+	"/list": handleList,
+	"/switch": handleSwitch,
+	"/unload": handleUnload,
+	"/info": handleInfo,
+	"/mode": handleMode,
+	"/run": handleRun,
+	"/eval": handleEval,
+	"/explain": handleExplain,
+	"/sessions": handleSessions,
+	"/history": handleHistory,
+	"/restore": handleRestore,
+	"/export": handleExport,
+	"/clear": handleClear,
+	"/model": handleModel
+};
+/**
+* Parse and execute a slash command if the input starts with /
+* Returns undefined if not a slash command
+*/
+async function parseSlashCommand(input, state) {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("/")) return void 0;
+	const parts = trimmed.split(/\s+/);
+	let cmd = parts[0]?.toLowerCase() ?? "";
+	const args = parts.slice(1);
+	if (state.config?.commands?.alias && cmd in state.config.commands.alias) {
+		const aliasTarget = state.config.commands.alias[cmd];
+		if (aliasTarget) {
+			const aliasParts = aliasTarget.split(/\s+/);
+			cmd = aliasParts[0]?.toLowerCase() ?? "";
+			args.unshift(...aliasParts.slice(1));
+		}
+	}
+	const handler = SLASH_COMMANDS[cmd];
+	if (handler) return await handler(args, state);
+	return { message: `Unknown command: ${cmd}. Type /help for available commands.` };
+}
+/**
+* Call the agent with user input and display response
+*/
+async function callAgent(state, userMessage) {
+	const { userAgent } = state;
+	const input = { message: userMessage };
+	const tracer = new require_terminal.TerminalTracer(userAgent.context, { suppressToolCallLogs: true });
+	try {
+		await tracer.run(userAgent, input);
+	} catch (error) {
+		console.error(chalk.default.red(`\nError: ${error instanceof Error ? error.message : String(error)}`));
+		if (error instanceof Error && error.stack) console.error(chalk.default.gray(error.stack));
+	}
+}
+/**
+* Run the shell REPL loop
+*/
+async function runShellLoop(state) {
+	for (;;) {
+		const input = await require_terminal_input.terminalInput({
+			message: getPrompt(state),
+			clear: true
+		});
+		if (!input?.trim()) continue;
+		const cmdResult = await parseSlashCommand(input, state);
+		if (cmdResult) {
+			if (cmdResult.message) console.log(cmdResult.message);
+			if (cmdResult.exit) break;
+			continue;
+		}
+		await callAgent(state, input.trim());
+	}
+}
+
+//#endregion
+exports.runShellLoop = runShellLoop;