autohand-cli 0.7.8 → 0.7.10

package/dist/chunk-YKSSNFDZ.js

@@ -0,0 +1,400 @@
+import {
+  saveConfig
+} from "./chunk-ZBIBLOZL.js";
+import {
+  I18nProvider
+} from "./chunk-NF7RIHJK.js";
+import {
+  t
+} from "./chunk-UET7BDX2.js";
+
+// src/commands/mcp.ts
+import chalk from "chalk";
+
+// src/ui/ink/components/McpServerList.tsx
+import { useState, useCallback } from "react";
+import { Box, Text, useInput, render } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function McpServerList({ servers, onToggle, onDone }) {
+  const [cursor, setCursor] = useState(0);
+  const [toggling, setToggling] = useState(null);
+  const handleToggle = useCallback(async () => {
+    const server = servers[cursor];
+    if (!server || toggling) return;
+    setToggling(server.name);
+    onToggle(server.name, server.status);
+    setToggling(null);
+  }, [cursor, servers, toggling, onToggle]);
+  useInput((char, key) => {
+    if (key.escape || char === "q" && !key.ctrl) {
+      onDone();
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : servers.length - 1);
+      return;
+    }
+    if (key.downArrow) {
+      setCursor((prev) => prev < servers.length - 1 ? prev + 1 : 0);
+      return;
+    }
+    if (char === " " || key.return) {
+      handleToggle();
+      return;
+    }
+  });
+  if (servers.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "MCP Servers" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "No MCP servers configured." }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "Add a server:  /mcp add ",
+        "<name>",
+        " ",
+        "<command>",
+        " [args...]"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Browse:        /mcp install" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press ESC or q to close" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "MCP Servers" }),
+    /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2500".repeat(56) }) }),
+    servers.map((server, i) => {
+      const isSelected = i === cursor;
+      const isToggling = toggling === server.name;
+      const statusIcon = server.status === "connected" ? "\u25CF" : server.status === "error" ? "\u25CF" : "\u25CB";
+      const statusColor = server.status === "connected" ? "green" : server.status === "error" ? "red" : "gray";
+      const statusLabel = server.status === "connected" ? "enabled" : server.status === "error" ? "error" : "disabled";
+      const toolsInfo = server.status === "connected" && server.toolCount > 0 ? ` (${server.toolCount} tools)` : "";
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: isSelected ? "yellow" : void 0, children: isSelected ? "\u25B8 " : "  " }),
+          /* @__PURE__ */ jsxs(Text, { color: statusColor, children: [
+            statusIcon,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { bold: isSelected, children: server.name.padEnd(24) }),
+          /* @__PURE__ */ jsx(Text, { color: statusColor, children: isToggling ? "toggling..." : statusLabel }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: toolsInfo })
+        ] }),
+        isSelected && server.status === "error" && server.error && /* @__PURE__ */ jsx(Box, { marginLeft: 4, children: /* @__PURE__ */ jsxs(Text, { color: "red", dimColor: true, children: [
+          "  ",
+          server.error
+        ] }) })
+      ] }, server.name);
+    }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u2191\u2193",
+        " navigate  ",
+        "\u23CE/space",
+        " toggle  ",
+        "q/esc",
+        " close"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Connected servers provide tools to the agent" })
+    ] })
+  ] });
+}
+async function showMcpServerList(options) {
+  if (!process.stdout.isTTY) {
+    return;
+  }
+  let currentServers = [...options.servers];
+  return new Promise((resolve) => {
+    let completed = false;
+    let instance;
+    const renderList = () => {
+      const element = /* @__PURE__ */ jsx(I18nProvider, { children: /* @__PURE__ */ jsx(
+        McpServerList,
+        {
+          servers: currentServers,
+          onToggle: async (name, status) => {
+            currentServers = await options.onToggle(name, status);
+            instance.rerender(
+              /* @__PURE__ */ jsx(I18nProvider, { children: /* @__PURE__ */ jsx(
+                McpServerList,
+                {
+                  servers: currentServers,
+                  onToggle: async (n, s) => {
+                    currentServers = await options.onToggle(n, s);
+                    renderList();
+                  },
+                  onDone: () => {
+                    if (completed) return;
+                    completed = true;
+                    instance.unmount();
+                    resolve();
+                  }
+                }
+              ) })
+            );
+          },
+          onDone: () => {
+            if (completed) return;
+            completed = true;
+            instance.unmount();
+            resolve();
+          }
+        }
+      ) });
+      if (instance) {
+        instance.rerender(element);
+      } else {
+        instance = render(element, { exitOnCtrlC: false });
+      }
+    };
+    renderList();
+  });
+}
+
+// src/commands/mcp.ts
+async function mcp(ctx, args = []) {
+  const { mcpManager, config } = ctx;
+  if (!mcpManager) {
+    return "MCP manager not available.";
+  }
+  const subcommand = args[0]?.toLowerCase();
+  switch (subcommand) {
+    case "connect":
+      return handleConnect(mcpManager, config, args.slice(1));
+    case "disconnect":
+      return handleDisconnect(mcpManager, args.slice(1));
+    case "list":
+    case "tools":
+      return handleListTools(mcpManager);
+    case "add":
+      return handleAdd(mcpManager, config, args.slice(1));
+    case "remove":
+    case "rm":
+      return handleRemove(mcpManager, config, args.slice(1));
+    default:
+      return showInteractiveList(mcpManager, config);
+  }
+}
+function buildServerItems(manager, config) {
+  const runtimeServers = manager.listServers();
+  const items = runtimeServers.map((s) => ({
+    name: s.name,
+    status: s.status,
+    toolCount: s.toolCount
+  }));
+  const runtimeNames = new Set(runtimeServers.map((s) => s.name));
+  const configServers = config?.mcp?.servers ?? [];
+  for (const cs of configServers) {
+    if (!runtimeNames.has(cs.name)) {
+      items.push({
+        name: cs.name,
+        status: "disconnected",
+        toolCount: 0
+      });
+    }
+  }
+  return items;
+}
+async function showInteractiveList(manager, config) {
+  const items = buildServerItems(manager, config);
+  if (items.length === 0) {
+    const lines = [];
+    lines.push("");
+    lines.push(chalk.bold.cyan(t("commands.mcp.title")));
+    lines.push(chalk.gray("\u2500".repeat(50)));
+    lines.push("");
+    lines.push(t("commands.mcp.noServers"));
+    lines.push("");
+    lines.push(chalk.gray("Add a server:"));
+    lines.push(chalk.gray("  /mcp add <name> <command> [args...]"));
+    lines.push("");
+    lines.push(chalk.gray("Browse community servers:"));
+    lines.push(chalk.gray("  /mcp install"));
+    return lines.join("\n");
+  }
+  await showMcpServerList({
+    servers: items,
+    onToggle: async (serverName, currentStatus) => {
+      if (currentStatus === "connected") {
+        try {
+          await manager.disconnect(serverName);
+        } catch {
+        }
+      } else {
+        const serverConfig = config?.mcp?.servers?.find((s) => s.name === serverName);
+        if (serverConfig) {
+          try {
+            await manager.connect(serverConfig);
+          } catch {
+          }
+        }
+      }
+      return buildServerItems(manager, config);
+    }
+  });
+  const updatedServers = manager.listServers();
+  const connectedCount = updatedServers.filter((s) => s.status === "connected").length;
+  const totalTools = updatedServers.reduce(
+    (sum, s) => sum + (s.status === "connected" ? s.toolCount : 0),
+    0
+  );
+  if (connectedCount > 0) {
+    return `${connectedCount} server${connectedCount > 1 ? "s" : ""} connected (${totalTools} tools available)`;
+  }
+  return null;
+}
+async function handleConnect(manager, config, args) {
+  const serverName = args[0];
+  if (!serverName) {
+    return "Usage: /mcp connect <server-name>";
+  }
+  const serverConfig = config?.mcp?.servers?.find((s) => s.name === serverName);
+  if (!serverConfig) {
+    return `Server "${serverName}" not found in config. Use /mcp add to add it first.`;
+  }
+  try {
+    console.log(chalk.cyan(t("commands.mcp.connecting")));
+    await manager.connect(serverConfig);
+    const tools = manager.getToolsForServer(serverName);
+    return `Connected to ${serverName} (${tools.length} tools available)`;
+  } catch (error) {
+    return `Failed to connect to ${serverName}: ${error instanceof Error ? error.message : "Unknown error"}`;
+  }
+}
+async function handleDisconnect(manager, args) {
+  const serverName = args[0];
+  if (!serverName) {
+    return "Usage: /mcp disconnect <server-name>";
+  }
+  try {
+    await manager.disconnect(serverName);
+    return `Disconnected from ${serverName}`;
+  } catch (error) {
+    return `Failed to disconnect from ${serverName}: ${error instanceof Error ? error.message : "Unknown error"}`;
+  }
+}
+function handleListTools(manager) {
+  const tools = manager.getAllTools();
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.cyan("MCP Tools"));
+  lines.push(chalk.gray("\u2500".repeat(50)));
+  if (tools.length === 0) {
+    lines.push("");
+    lines.push("No tools available. Connect to an MCP server first.");
+    return lines.join("\n");
+  }
+  const byServer = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const existing = byServer.get(tool.serverName) ?? [];
+    existing.push(tool);
+    byServer.set(tool.serverName, existing);
+  }
+  for (const [serverName, serverTools] of byServer) {
+    lines.push("");
+    lines.push(chalk.bold(`${serverName} (${serverTools.length} tools):`));
+    for (const tool of serverTools) {
+      const shortName = tool.name.replace(`mcp__${serverName}__`, "");
+      lines.push(`  ${chalk.yellow(shortName)} ${chalk.gray(tool.description.slice(0, 60))}`);
+    }
+  }
+  lines.push("");
+  lines.push(chalk.gray(`Total: ${tools.length} tools from ${byServer.size} servers`));
+  return lines.join("\n");
+}
+async function handleAdd(manager, config, args) {
+  if (args.length < 2) {
+    return "Usage: /mcp add <name> <command> [args...]";
+  }
+  if (!config) {
+    return "Config not available.";
+  }
+  const [name, command, ...serverArgs] = args;
+  if (config.mcp?.servers?.some((s) => s.name === name)) {
+    return `Server "${name}" already exists in config. Use /mcp remove first.`;
+  }
+  if (!config.mcp) {
+    config.mcp = {};
+  }
+  if (!config.mcp.servers) {
+    config.mcp.servers = [];
+  }
+  const newServer = {
+    name,
+    transport: "stdio",
+    command,
+    args: serverArgs.length > 0 ? serverArgs : void 0,
+    autoConnect: true
+  };
+  config.mcp.servers.push(newServer);
+  try {
+    await saveConfig(config);
+    try {
+      await manager.connect(newServer);
+      const tools = manager.getToolsForServer(name);
+      return `Added and connected to "${name}" (${tools.length} tools available)`;
+    } catch (connectError) {
+      return `Added "${name}" to config but failed to connect: ${connectError instanceof Error ? connectError.message : "Unknown error"}`;
+    }
+  } catch (error) {
+    return `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`;
+  }
+}
+async function handleRemove(manager, config, args) {
+  const serverName = args[0];
+  if (!serverName) {
+    return "Usage: /mcp remove <server-name>";
+  }
+  if (!config) {
+    return "Config not available.";
+  }
+  const serverIndex = config.mcp?.servers?.findIndex((s) => s.name === serverName);
+  if (serverIndex === void 0 || serverIndex < 0) {
+    return `Server "${serverName}" not found in config.`;
+  }
+  try {
+    await manager.disconnect(serverName);
+  } catch {
+  }
+  config.mcp.servers.splice(serverIndex, 1);
+  try {
+    await saveConfig(config);
+    return `Removed "${serverName}" from config`;
+  } catch (error) {
+    return `Failed to save config: ${error instanceof Error ? error.message : "Unknown error"}`;
+  }
+}
+var metadata = {
+  command: "/mcp",
+  description: t("commands.mcp.description"),
+  implemented: true
+};
+var installMetadata = {
+  command: "/mcp install",
+  description: t("commands.mcp.installDescription"),
+  implemented: true
+};
+
+export {
+  mcp,
+  metadata,
+  installMetadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Interactive MCP Server toggle list - Ink component
+ * Allows users to enable/disable MCP servers with arrow keys + space
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * MCP command - List and manage MCP (Model Context Protocol) servers
+ */

package/dist/{chunk-VRI7EXV6.js → chunk-YMDLUTF2.js}

@@ -1,3 +1,7 @@
+import {
+  t
+} from "./chunk-UET7BDX2.js";
+
 // src/commands/init.ts
 async function init(ctx) {
   await ctx.createAgentsFile();
@@ -5,7 +9,7 @@ async function init(ctx) {
 }
 var metadata = {
   command: "/init",
-  description: "create an AGENTS.md file with instructions for Autohand",
+  description: t("commands.init.description"),
   implemented: true
 };
 

package/dist/chunk-YVY27BJT.js

@@ -0,0 +1,85 @@
+import {
+  saveConfig
+} from "./chunk-ZBIBLOZL.js";
+import {
+  showModal
+} from "./chunk-PNSRJT46.js";
+import {
+  LANGUAGE_DISPLAY_NAMES,
+  SUPPORTED_LOCALES,
+  changeLanguage,
+  getCurrentLocale,
+  t
+} from "./chunk-UET7BDX2.js";
+
+// src/commands/language.ts
+import chalk from "chalk";
+async function language(ctx) {
+  const currentLocale = getCurrentLocale();
+  const currentDisplayName = LANGUAGE_DISPLAY_NAMES[currentLocale];
+  console.log(chalk.cyan(`
+\u{1F310} ${t("commands.language.title")}
+`));
+  console.log(chalk.gray(`${t("commands.language.currentLanguage", { language: currentDisplayName })}`));
+  console.log();
+  const options = SUPPORTED_LOCALES.map((locale) => ({
+    label: locale === currentLocale ? `${LANGUAGE_DISPLAY_NAMES[locale]} (${t("common.current")})` : LANGUAGE_DISPLAY_NAMES[locale],
+    value: locale
+  }));
+  const result = await showModal({
+    title: t("commands.language.selectPrompt"),
+    options,
+    initialIndex: SUPPORTED_LOCALES.indexOf(currentLocale)
+  });
+  if (!result) {
+    console.log(chalk.gray("\nLanguage selection cancelled."));
+    return null;
+  }
+  const selected = result.value;
+  if (selected === currentLocale) {
+    console.log(chalk.gray(`
+${t("commands.language.noChange")}`));
+    return null;
+  }
+  await changeLanguage(selected);
+  ctx.config.ui = { ...ctx.config.ui, locale: selected };
+  await saveConfig(ctx.config);
+  const newDisplayName = LANGUAGE_DISPLAY_NAMES[selected];
+  console.log(chalk.green(`
+\u2713 ${t("commands.language.changed", { language: newDisplayName })}`));
+  console.log();
+  return null;
+}
+async function languageInfo() {
+  const currentLocale = getCurrentLocale();
+  const currentDisplayName = LANGUAGE_DISPLAY_NAMES[currentLocale];
+  console.log(chalk.cyan(`
+\u{1F310} ${t("commands.language.title")}
+`));
+  console.log(chalk.gray(`${t("commands.language.currentLanguage", { language: currentDisplayName })}`));
+  console.log(chalk.gray(`Locale code: ${chalk.white(currentLocale)}`));
+  console.log();
+  console.log(chalk.gray("Supported languages:"));
+  for (const locale of SUPPORTED_LOCALES) {
+    const marker = locale === currentLocale ? chalk.green("\u25CF") : chalk.gray("\u25CB");
+    console.log(`  ${marker} ${LANGUAGE_DISPLAY_NAMES[locale]}`);
+  }
+  console.log();
+  return null;
+}
+var metadata = {
+  command: "/language",
+  description: "change display language",
+  implemented: true
+};
+
+export {
+  language,
+  languageInfo,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */