@within-7/minto 0.3.9 → 0.4.0

package/dist/commands/export.js

@@ -1,99 +1,17 @@
-import React, { useState } from "react";
-import { Box, Text, useInput } from "ink";
-import { writeFile } from "fs/promises";
+import React, { useState, useCallback, useMemo } from "react";
+import { writeFile, readFile } from "fs/promises";
+import { existsSync, readdirSync } from "fs";
 import { join } from "path";
+import { homedir } from "os";
 import { getMessagesGetter } from "../messages.js";
 import { getCwd } from "../utils/state.js";
-import { loadGlobalConfig, loadProjectConfig } from "../core/config/index.js";
-import { SEMANTIC_COLORS } from "../constants/colors.js";
-const EXPORT_OPTIONS = [
-  {
-    type: "conversation",
-    label: "Conversation",
-    description: "Export full conversation history as JSON"
-  },
-  {
-    type: "config",
-    label: "Configuration",
-    description: "Export current configuration settings"
-  },
-  {
-    type: "summary",
-    label: "Summary",
-    description: "Export a markdown summary of the session"
-  }
-];
-const ExportMenu = ({ onDone }) => {
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const [exporting, setExporting] = useState(false);
-  const [result, setResult] = useState(null);
-  useInput(async (input, key) => {
-    if (exporting) return;
-    if (key.upArrow) {
-      setSelectedIndex(Math.max(0, selectedIndex - 1));
-    } else if (key.downArrow) {
-      setSelectedIndex(Math.min(EXPORT_OPTIONS.length - 1, selectedIndex + 1));
-    } else if (key.return) {
-      await handleExport(EXPORT_OPTIONS[selectedIndex].type);
-    } else if (input === "q" || key.escape) {
-      onDone();
-    }
-  });
-  const handleExport = async (type) => {
-    setExporting(true);
-    try {
-      const cwd = getCwd();
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      let filename;
-      let content;
-      switch (type) {
-        case "conversation": {
-          const messages = getMessagesGetter()();
-          filename = `minto-conversation-${timestamp}.json`;
-          content = JSON.stringify(messages, null, 2);
-          break;
-        }
-        case "config": {
-          const [globalConfig, projectConfig] = await Promise.all([
-            Promise.resolve(loadGlobalConfig()),
-            Promise.resolve(loadProjectConfig(cwd))
-          ]);
-          filename = `minto-config-${timestamp}.json`;
-          content = JSON.stringify(
-            {
-              global: globalConfig,
-              project: projectConfig
-            },
-            null,
-            2
-          );
-          break;
-        }
-        case "summary": {
-          const messages = getMessagesGetter()();
-          filename = `minto-summary-${timestamp}.md`;
-          content = generateSummary(messages);
-          break;
-        }
-      }
-      const filepath = join(cwd, filename);
-      await writeFile(filepath, content, "utf-8");
-      setResult({
-        success: true,
-        message: `Exported to ${filename}`
-      });
-      setTimeout(() => onDone(`Exported to ${filepath}`), 2e3);
-    } catch (error) {
-      setResult({
-        success: false,
-        message: `Export failed: ${error instanceof Error ? error.message : String(error)}`
-      });
-    } finally {
-      setExporting(false);
-    }
-  };
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, "Export Data")), !result ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, EXPORT_OPTIONS.map((option, index) => /* @__PURE__ */ React.createElement(Box, { key: option.type, paddingLeft: 1 }, /* @__PURE__ */ React.createElement(Text, { color: index === selectedIndex ? "cyan" : void 0 }, index === selectedIndex ? "\u25B6 " : "  ", /* @__PURE__ */ React.createElement(Text, { bold: true }, option.label), /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.dim }, " ", "- ", option.description))))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.dim }, "\u2191/\u2193: Navigate | Enter: Export | q/Esc: Cancel"))) : /* @__PURE__ */ React.createElement(Box, null, result.success ? /* @__PURE__ */ React.createElement(Text, { color: "green" }, "\u2713 ", result.message) : /* @__PURE__ */ React.createElement(Text, { color: "red" }, "\u2717 ", result.message)), exporting && /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "Exporting...")));
-};
+import { getGlobalConfig, getCurrentProjectConfig } from "../utils/config.js";
+import { t } from "../i18n/index.js";
+import { listMarketplaces } from "../utils/marketplaceManager.js";
+import { loadAllPlugins } from "../utils/pluginLoader.js";
+import { loadAllSkills } from "../utils/skillLoader.js";
+import { loadCustomCommands } from "../services/customCommands.js";
+import { TabbedListView } from "../components/TabbedListView/TabbedListView.js";
 function generateSummary(messages) {
   const lines = [
     "# Minto Session Summary",
@@ -137,11 +55,683 @@ function generateSummary(messages) {
   }
   return lines.join("\n");
 }
+function parseHooksFile(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.hooks) {
+      return null;
+    }
+    const result = {};
+    if (parsed.hooks.SessionStart) {
+      result.sessionStart = parsed.hooks.SessionStart.flatMap(
+        (m) => m.hooks || []
+      );
+    }
+    if (parsed.hooks.SessionEnd) {
+      result.sessionEnd = parsed.hooks.SessionEnd.flatMap(
+        (m) => m.hooks || []
+      );
+    }
+    if (parsed.hooks.UserPromptSubmit) {
+      result.userPromptSubmit = parsed.hooks.UserPromptSubmit.flatMap(
+        (m) => m.hooks || []
+      );
+    }
+    if (parsed.hooks.PreToolUse) {
+      result.preToolUse = parsed.hooks.PreToolUse;
+    }
+    if (parsed.hooks.PostToolUse) {
+      result.postToolUse = parsed.hooks.PostToolUse;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function loadHooksConfigByScope(scope) {
+  let userHooks = null;
+  let projectHooks = null;
+  if (scope === "user" || scope === "all") {
+    const mintoPath = join(homedir(), ".minto", "hooks.json");
+    const claudePath = join(homedir(), ".claude", "hooks.json");
+    const hooksPath = existsSync(mintoPath) ? mintoPath : existsSync(claudePath) ? claudePath : null;
+    if (hooksPath) {
+      try {
+        const content = await readFile(hooksPath, "utf-8");
+        userHooks = parseHooksFile(content);
+      } catch {
+      }
+    }
+  }
+  if (scope === "project" || scope === "all") {
+    const cwd = getCwd();
+    const mintoPath = join(cwd, ".minto", "hooks.json");
+    const claudePath = join(cwd, ".claude", "hooks.json");
+    const hooksPath = existsSync(mintoPath) ? mintoPath : existsSync(claudePath) ? claudePath : null;
+    if (hooksPath) {
+      try {
+        const content = await readFile(hooksPath, "utf-8");
+        projectHooks = parseHooksFile(content);
+      } catch {
+      }
+    }
+  }
+  return { userHooks, projectHooks };
+}
+function parseAgentFile(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) return null;
+  const frontmatter = frontmatterMatch[1];
+  const body = frontmatterMatch[2].trim();
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  const descMatch = frontmatter.match(/^description:\s*"?([^"\n]+)"?$/m);
+  const toolsMatch = frontmatter.match(/^tools:\s*(.+)$/m);
+  const modelMatch = frontmatter.match(/^model_name:\s*(.+)$/m);
+  const colorMatch = frontmatter.match(/^color:\s*"?([^"\n]+)"?$/m);
+  if (!nameMatch || !descMatch) return null;
+  let tools = "*";
+  if (toolsMatch) {
+    const toolsValue = toolsMatch[1].trim();
+    if (toolsValue === "*") {
+      tools = "*";
+    } else {
+      try {
+        tools = JSON.parse(toolsValue);
+      } catch {
+        tools = "*";
+      }
+    }
+  }
+  return {
+    name: nameMatch[1].trim(),
+    description: descMatch[1].trim(),
+    tools,
+    systemPrompt: body,
+    model: modelMatch ? modelMatch[1].trim() : void 0,
+    color: colorMatch ? colorMatch[1].trim() : void 0
+  };
+}
+async function scanAgentsDir(agentsDir) {
+  const agentMap = /* @__PURE__ */ new Map();
+  if (!existsSync(agentsDir)) return agentMap;
+  try {
+    const files = readdirSync(agentsDir);
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      const filePath = join(agentsDir, file);
+      const content = await readFile(filePath, "utf-8");
+      const agent = parseAgentFile(content);
+      if (agent) {
+        agentMap.set(agent.name, agent);
+      }
+    }
+  } catch {
+  }
+  return agentMap;
+}
+async function loadAgentsConfigByScope(scope) {
+  const userAgentMap = /* @__PURE__ */ new Map();
+  const projectAgentMap = /* @__PURE__ */ new Map();
+  if (scope === "user" || scope === "all") {
+    const claudeAgents = await scanAgentsDir(
+      join(homedir(), ".claude", "agents")
+    );
+    const mintoAgents = await scanAgentsDir(join(homedir(), ".minto", "agents"));
+    for (const [name, agent] of claudeAgents) {
+      userAgentMap.set(name, agent);
+    }
+    for (const [name, agent] of mintoAgents) {
+      userAgentMap.set(name, agent);
+    }
+  }
+  if (scope === "project" || scope === "all") {
+    const cwd = getCwd();
+    const claudeAgents = await scanAgentsDir(join(cwd, ".claude", "agents"));
+    const mintoAgents = await scanAgentsDir(join(cwd, ".minto", "agents"));
+    for (const [name, agent] of claudeAgents) {
+      projectAgentMap.set(name, agent);
+    }
+    for (const [name, agent] of mintoAgents) {
+      projectAgentMap.set(name, agent);
+    }
+  }
+  return {
+    userAgents: Array.from(userAgentMap.values()),
+    projectAgents: Array.from(projectAgentMap.values())
+  };
+}
+function getPluginScope(location) {
+  const cwd = getCwd();
+  if (location.startsWith(join(cwd, ".minto")) || location.startsWith(join(cwd, ".claude"))) {
+    return "project";
+  }
+  return "user";
+}
+async function getInstalledPluginSourcesByScope(scope) {
+  const plugins = loadAllPlugins();
+  const userPlugins = [];
+  const projectPlugins = [];
+  for (const plugin of plugins) {
+    const pluginScope = getPluginScope(plugin.location);
+    if (scope === "user" && pluginScope !== "user") continue;
+    if (scope === "project" && pluginScope !== "project") continue;
+    const metaPath = join(plugin.location, ".marketplace-meta.json");
+    let pluginName;
+    if (existsSync(metaPath)) {
+      try {
+        const content = await readFile(metaPath, "utf-8");
+        const meta = JSON.parse(content);
+        pluginName = meta.plugin && meta.marketplace ? `${meta.plugin}@${meta.marketplace}` : meta.plugin || plugin.name;
+      } catch {
+        pluginName = plugin.name;
+      }
+    } else {
+      pluginName = plugin.name;
+    }
+    if (pluginScope === "user") {
+      userPlugins.push(pluginName);
+    } else {
+      projectPlugins.push(pluginName);
+    }
+  }
+  return { userPlugins, projectPlugins };
+}
+function loadStandaloneSkillsByScope(scope) {
+  const allSkills = loadAllSkills();
+  const userSkills = [];
+  const projectSkills = [];
+  for (const skill of allSkills) {
+    if (skill.pluginName !== "standalone") continue;
+    const teamSkill = {
+      name: skill.name,
+      description: skill.config.description,
+      content: skill.config.content || "",
+      argumentHint: skill.config.argumentHint,
+      disableModelInvocation: skill.config.disableModelInvocation,
+      userInvocable: skill.config.userInvocable,
+      allowedTools: skill.config.allowedTools,
+      model: skill.config.model,
+      context: skill.config.context,
+      agent: skill.config.agent
+    };
+    if (skill.source === "user" && (scope === "user" || scope === "all")) {
+      userSkills.push(teamSkill);
+    } else if (skill.source === "project" && (scope === "project" || scope === "all")) {
+      projectSkills.push(teamSkill);
+    }
+  }
+  return { userSkills, projectSkills };
+}
+async function loadStandaloneCommandsByScope(scope) {
+  const allCommands = await loadCustomCommands();
+  const userCommands = [];
+  const projectCommands = [];
+  for (const cmd of allCommands) {
+    if (cmd.name.startsWith("plugin:")) continue;
+    const teamCmd = {
+      name: cmd.name,
+      description: cmd.description,
+      content: "",
+      // Will be populated from getPromptForCommand
+      aliases: cmd.aliases,
+      enabled: cmd.isEnabled,
+      hidden: cmd.isHidden,
+      progressMessage: cmd.progressMessage,
+      argNames: cmd.argNames
+    };
+    try {
+      const messages = await cmd.getPromptForCommand("");
+      if (messages.length > 0) {
+        const firstMsg = messages[0];
+        if (typeof firstMsg.content === "string") {
+          teamCmd.content = firstMsg.content;
+        }
+      }
+    } catch {
+      continue;
+    }
+    if (cmd.scope === "user" && (scope === "user" || scope === "all")) {
+      userCommands.push(teamCmd);
+    } else if (cmd.scope === "project" && (scope === "project" || scope === "all")) {
+      projectCommands.push(teamCmd);
+    }
+  }
+  return { userCommands, projectCommands };
+}
+function getMarketplaceUrls() {
+  const marketplaces = listMarketplaces();
+  const urls = [];
+  for (const mp of marketplaces) {
+    if (mp.source.type === "github") {
+      urls.push(`https://github.com/${mp.source.repo}.git`);
+    } else if (mp.source.type === "url") {
+      urls.push(mp.source.url);
+    } else if (mp.source.type === "local") {
+      urls.push(mp.source.path);
+    }
+  }
+  return urls;
+}
+const PROXY_ENV_KEYS = /* @__PURE__ */ new Set([
+  "no_proxy",
+  "NO_PROXY",
+  "http_proxy",
+  "HTTP_PROXY",
+  "https_proxy",
+  "HTTPS_PROXY",
+  "ALL_PROXY",
+  "all_proxy"
+]);
+function buildMcpServersConfig(mcpServers, usePlaceholders) {
+  const result = {};
+  for (const [name, server] of Object.entries(mcpServers)) {
+    if (server.type === "sse") {
+      result[name] = {
+        type: "sse",
+        url: server.url,
+        enabled: server.enabled
+      };
+    } else {
+      const env = server.env ? usePlaceholders ? Object.fromEntries(
+        Object.entries(server.env).map(([key, value]) => {
+          const isProxyKey = PROXY_ENV_KEYS.has(key);
+          const isSecret = !isProxyKey && (key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("token") || key.toLowerCase().includes("password"));
+          return [key, isSecret ? `\${${key}}` : value];
+        })
+      ) : server.env : void 0;
+      result[name] = {
+        type: "stdio",
+        command: server.command,
+        args: server.args,
+        env,
+        enabled: server.enabled
+      };
+    }
+  }
+  return result;
+}
+async function buildTeamConfig(scope, usePlaceholders) {
+  const cwd = getCwd();
+  const globalConfig = getGlobalConfig();
+  const projectConfig = getCurrentProjectConfig();
+  const scopeLabel = scope === "user" ? "User Configuration" : scope === "project" ? `Project: ${cwd.split("/").pop()}` : `All: ${cwd.split("/").pop()}`;
+  const config = {
+    version: "1.0",
+    name: scopeLabel,
+    description: `Exported from Minto on ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    scope
+  };
+  if (scope !== "project") {
+    if (globalConfig.modelProfiles && globalConfig.modelProfiles.length > 0) {
+      config.models = {
+        profiles: globalConfig.modelProfiles.map((profile) => ({
+          name: profile.name,
+          provider: profile.provider,
+          modelName: profile.modelName,
+          baseURL: profile.baseURL,
+          apiKey: usePlaceholders ? `\${${profile.provider.toUpperCase()}_API_KEY}` : profile.apiKey,
+          maxTokens: profile.maxTokens,
+          contextLength: profile.contextLength,
+          reasoningEffort: profile.reasoningEffort,
+          isActive: profile.isActive
+        })),
+        pointers: globalConfig.modelPointers,
+        defaultModel: globalConfig.defaultModelName
+      };
+    }
+  }
+  if (scope === "user") {
+    if (globalConfig.mcpServers && Object.keys(globalConfig.mcpServers).length > 0) {
+      config.mcpServers = buildMcpServersConfig(
+        globalConfig.mcpServers,
+        usePlaceholders
+      );
+    }
+  } else if (scope === "project") {
+    if (projectConfig.mcpServers && Object.keys(projectConfig.mcpServers).length > 0) {
+      config.mcpServers = buildMcpServersConfig(
+        projectConfig.mcpServers,
+        usePlaceholders
+      );
+    }
+  } else {
+    const merged = {
+      ...globalConfig.mcpServers,
+      ...projectConfig.mcpServers
+    };
+    if (Object.keys(merged).length > 0) {
+      config.mcpServers = buildMcpServersConfig(merged, usePlaceholders);
+    }
+  }
+  const marketplaceUrls = getMarketplaceUrls();
+  const { userPlugins, projectPlugins } = await getInstalledPluginSourcesByScope(scope);
+  if (marketplaceUrls.length > 0 || userPlugins.length > 0 || projectPlugins.length > 0) {
+    config.plugins = {};
+    if (marketplaceUrls.length > 0) {
+      config.plugins.marketplaces = marketplaceUrls;
+    }
+    if (userPlugins.length > 0) {
+      config.plugins.userInstall = userPlugins;
+    }
+    if (projectPlugins.length > 0) {
+      config.plugins.projectInstall = projectPlugins;
+    }
+  }
+  const { userAgents, projectAgents } = await loadAgentsConfigByScope(scope);
+  if (userAgents.length > 0 || projectAgents.length > 0) {
+    config.agents = {};
+    if (userAgents.length > 0) {
+      config.agents.userAgents = userAgents;
+    }
+    if (projectAgents.length > 0) {
+      config.agents.projectAgents = projectAgents;
+    }
+  }
+  const { userSkills, projectSkills } = loadStandaloneSkillsByScope(scope);
+  if (userSkills.length > 0 || projectSkills.length > 0) {
+    config.skills = {};
+    if (userSkills.length > 0) {
+      config.skills.userSkills = userSkills;
+    }
+    if (projectSkills.length > 0) {
+      config.skills.projectSkills = projectSkills;
+    }
+  }
+  const { userCommands, projectCommands } = await loadStandaloneCommandsByScope(scope);
+  if (userCommands.length > 0 || projectCommands.length > 0) {
+    config.commands = {};
+    if (userCommands.length > 0) {
+      config.commands.userCommands = userCommands;
+    }
+    if (projectCommands.length > 0) {
+      config.commands.projectCommands = projectCommands;
+    }
+  }
+  const { userHooks, projectHooks } = await loadHooksConfigByScope(scope);
+  if (userHooks) {
+    config.hooks = userHooks;
+  }
+  if (projectHooks) {
+    config.projectHooks = projectHooks;
+  }
+  if (scope !== "project") {
+    config.settings = {
+      theme: globalConfig.theme,
+      verbose: globalConfig.verbose,
+      compressionMode: globalConfig.compressionMode,
+      thinking: globalConfig.thinking,
+      proxy: globalConfig.proxy,
+      stream: globalConfig.stream,
+      language: globalConfig.language,
+      safetyMode: globalConfig.safetyMode,
+      skipOnboarding: globalConfig.hasCompletedOnboarding
+    };
+  }
+  if (usePlaceholders) {
+    config.postInstallInstructions = `
+1. Set environment variables for API keys (e.g., ANTHROPIC_API_KEY, OPENAI_API_KEY)
+2. Run 'minto' to start using your configured setup
+`.trim();
+  }
+  return config;
+}
+async function exportRuntimeConfig(scope) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  if (scope === "user") {
+    const globalConfig = getGlobalConfig();
+    return {
+      content: JSON.stringify({ global: globalConfig }, null, 2),
+      filename: `minto-config-user-${timestamp}.json`
+    };
+  } else if (scope === "project") {
+    const projectConfig = getCurrentProjectConfig();
+    return {
+      content: JSON.stringify({ project: projectConfig }, null, 2),
+      filename: `minto-config-project-${timestamp}.json`
+    };
+  } else {
+    const globalConfig = getGlobalConfig();
+    const projectConfig = getCurrentProjectConfig();
+    return {
+      content: JSON.stringify(
+        { global: globalConfig, project: projectConfig },
+        null,
+        2
+      ),
+      filename: `minto-config-all-${timestamp}.json`
+    };
+  }
+}
+async function exportTeamTemplate(scope, usePlaceholders) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const teamConfig = await buildTeamConfig(scope, usePlaceholders);
+  return {
+    content: JSON.stringify(teamConfig, null, 2),
+    filename: `minto-team-${scope}-${timestamp}.json`
+  };
+}
+const EXPORT_TABS = [
+  { id: "team", label: t("commands.export.typeTeam") },
+  { id: "runtime", label: t("commands.export.typeRuntime") },
+  { id: "conversation", label: t("commands.export.typeConversation") },
+  { id: "summary", label: t("commands.export.typeSummary") }
+];
+function getItemsForTab(tabId) {
+  switch (tabId) {
+    case "team":
+      return [
+        {
+          id: "team-user-include",
+          label: t("commands.export.itemTeamUserInclude"),
+          description: t("commands.export.scopeUserDesc"),
+          data: {
+            category: "team",
+            scope: "user",
+            sensitive: "include"
+          }
+        },
+        {
+          id: "team-user-placeholder",
+          label: t("commands.export.itemTeamUserPlaceholder"),
+          description: t("commands.export.scopeUserDesc"),
+          data: {
+            category: "team",
+            scope: "user",
+            sensitive: "placeholder"
+          }
+        },
+        {
+          id: "team-project-include",
+          label: t("commands.export.itemTeamProjectInclude"),
+          description: t("commands.export.scopeProjectDesc"),
+          data: {
+            category: "team",
+            scope: "project",
+            sensitive: "include"
+          }
+        },
+        {
+          id: "team-project-placeholder",
+          label: t("commands.export.itemTeamProjectPlaceholder"),
+          description: t("commands.export.scopeProjectDesc"),
+          data: {
+            category: "team",
+            scope: "project",
+            sensitive: "placeholder"
+          }
+        },
+        {
+          id: "team-all-include",
+          label: t("commands.export.itemTeamAllInclude"),
+          description: t("commands.export.scopeAllDesc"),
+          data: {
+            category: "team",
+            scope: "all",
+            sensitive: "include"
+          }
+        },
+        {
+          id: "team-all-placeholder",
+          label: t("commands.export.itemTeamAllPlaceholder"),
+          description: t("commands.export.scopeAllDesc"),
+          data: {
+            category: "team",
+            scope: "all",
+            sensitive: "placeholder"
+          }
+        }
+      ];
+    case "runtime":
+      return [
+        {
+          id: "runtime-user",
+          label: t("commands.export.itemRuntimeUser"),
+          description: t("commands.export.scopeUserDesc"),
+          data: {
+            category: "runtime",
+            scope: "user",
+            sensitive: "include"
+          }
+        },
+        {
+          id: "runtime-project",
+          label: t("commands.export.itemRuntimeProject"),
+          description: t("commands.export.scopeProjectDesc"),
+          data: {
+            category: "runtime",
+            scope: "project",
+            sensitive: "include"
+          }
+        },
+        {
+          id: "runtime-all",
+          label: t("commands.export.itemRuntimeAll"),
+          description: t("commands.export.scopeAllDesc"),
+          data: {
+            category: "runtime",
+            scope: "all",
+            sensitive: "include"
+          }
+        }
+      ];
+    case "conversation":
+      return [
+        {
+          id: "conversation",
+          label: t("commands.export.itemConversation"),
+          description: t("commands.export.typeConversationDesc"),
+          data: {
+            category: "conversation",
+            scope: "user",
+            sensitive: "include"
+          }
+        }
+      ];
+    case "summary":
+      return [
+        {
+          id: "summary",
+          label: t("commands.export.itemSummary"),
+          description: t("commands.export.typeSummaryDesc"),
+          data: {
+            category: "summary",
+            scope: "user",
+            sensitive: "include"
+          }
+        }
+      ];
+    default:
+      return [];
+  }
+}
+const ExportMenu = ({ onDone }) => {
+  const [activeTab, setActiveTab] = useState("team");
+  const [statusOverlay, setStatusOverlay] = useState(null);
+  const [searchQuery, setSearchQuery] = useState("");
+  const items = useMemo(() => getItemsForTab(activeTab), [activeTab]);
+  const handleSelect = useCallback(async (item) => {
+    const data = item.data;
+    setStatusOverlay({
+      type: "loading",
+      message: t("commands.export.exporting")
+    });
+    try {
+      const cwd = getCwd();
+      let filename;
+      let content;
+      switch (data.category) {
+        case "conversation": {
+          const messages = getMessagesGetter()();
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          filename = `minto-conversation-${timestamp}.json`;
+          content = JSON.stringify(messages, null, 2);
+          break;
+        }
+        case "summary": {
+          const messages = getMessagesGetter()();
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+          filename = `minto-summary-${timestamp}.md`;
+          content = generateSummary(messages);
+          break;
+        }
+        case "runtime": {
+          const result = await exportRuntimeConfig(data.scope);
+          filename = result.filename;
+          content = result.content;
+          break;
+        }
+        case "team": {
+          const usePlaceholders = data.sensitive === "placeholder";
+          const result = await exportTeamTemplate(data.scope, usePlaceholders);
+          filename = result.filename;
+          content = result.content;
+          break;
+        }
+      }
+      const filepath = join(cwd, filename);
+      await writeFile(filepath, content, "utf-8");
+      setStatusOverlay({
+        type: "success",
+        message: `${t("commands.export.success")} ${filename}`
+      });
+    } catch (error) {
+      setStatusOverlay({
+        type: "error",
+        message: `${t("commands.export.failed")}: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }, []);
+  const handleClose = useCallback(() => {
+    onDone();
+  }, [onDone]);
+  return /* @__PURE__ */ React.createElement(
+    TabbedListView,
+    {
+      title: t("commands.export.title"),
+      tabs: EXPORT_TABS,
+      activeTab,
+      onTabChange: (tab) => {
+        setActiveTab(tab);
+        setSearchQuery("");
+      },
+      items,
+      searchEnabled: false,
+      searchQuery,
+      onSearchChange: setSearchQuery,
+      onSelect: handleSelect,
+      onClose: handleClose,
+      footerHint: t("commands.export.footerHint"),
+      statusOverlay,
+      statusDismissHint: "Esc Close"
+    }
+  );
+};
 const command = {
   name: "export",
-  description: "Export session data, configuration, or conversation history",
+  description: t("commands.export.description"),
   isEnabled: true,
   isHidden: false,
+  hidePromptInput: true,
   type: "local-jsx",
   userFacingName() {
     return this.name;