@hope666/melu 1.0.0

package/dist/i18n.js

@@ -0,0 +1,1024 @@
+const SUPPORTED_UI_LANGUAGES = [
+    { value: "en", key: "1", label: "English", aliases: ["1", "en", "english"] },
+    { value: "zh-CN", key: "2", label: "简体中文", aliases: ["2", "zh-cn", "zh_hans", "zh", "simplified", "simplified chinese"] },
+    { value: "zh-TW", key: "3", label: "繁體中文", aliases: ["3", "zh-tw", "zh_hant", "traditional", "traditional chinese"] },
+    { value: "ja", key: "4", label: "日本語", aliases: ["4", "ja", "jp", "japanese"] },
+    { value: "ko", key: "5", label: "한국어", aliases: ["5", "ko", "kr", "korean"] },
+    { value: "fr", key: "6", label: "Français", aliases: ["6", "fr", "french", "francais"] },
+    { value: "ru", key: "7", label: "Русский", aliases: ["7", "ru", "russian"] },
+    { value: "de", key: "8", label: "Deutsch", aliases: ["8", "de", "german", "deutsch"] },
+    { value: "es", key: "9", label: "Español", aliases: ["9", "es", "spanish", "espanol", "español"] },
+    { value: "pt", key: "10", label: "Português", aliases: ["10", "pt", "portuguese", "portugues", "português", "pt-br", "pt-pt"] },
+];
+const MESSAGES = {
+    en: {
+        programDescription: "Melu - transparent AI memory proxy",
+        cmdInitDescription: "Initial setup: create directories, config, and the default memory file",
+        cmdRunDescription: "Run any agent with persistent memory",
+        cmdStopDescription: "Stop the background proxy service",
+        cmdListDescription: "List current memory entries",
+        cmdDeleteDescription: "Delete a memory entry by ID prefix",
+        cmdClearDescription: "Clear current memory entries (with confirmation)",
+        cmdExportDescription: "Export current memory to a .memory file",
+        cmdImportDescription: "Import memories from a .memory file",
+        cmdStatusDescription: "Show service status, memory count, and model info",
+        optMirrorDescription: "Model mirror source (huggingface | modelscope)",
+        optMemoryDescription: "Memory file",
+        optMemoryNameOrPathDescription: "Memory name or path",
+        optAllDescription: "Include inactive memories",
+        optYesDescription: "Skip confirmation",
+        optPortDescription: "Proxy port",
+        optOutputDescription: "Output file path",
+        argCommandDescription: "Command to execute",
+        initTitle: "Melu setup",
+        labelDirectory: "Directory",
+        labelConfig: "Config",
+        labelMemory: "Memory",
+        initComplete: "Setup complete!",
+        labelMirrorSource: "Mirror source",
+        embeddingModelReady: "Embedding model is ready.",
+        usageRunClaude: "Usage: melu run -- claude",
+        runProxy: "Proxy",
+        runMemory: "Memory",
+        memoryExtractionFailed: "[Melu] Memory extraction failed:",
+        proxyNotRunning: "Proxy service is not running",
+        proxyStopped: "Proxy service stopped (PID: {pid})",
+        proxyAlreadyGone: "Proxy service is no longer running",
+        memoryFileNotFound: "Memory file not found: {path}",
+        noMemories: "No memories yet",
+        memoriesTitle: "Memories ({count})",
+        tableType: "Type",
+        tableSubject: "Subject",
+        tableSummary: "Summary",
+        tableCreatedAt: "Created At",
+        tableStatus: "Status",
+        listShowHint: "Use \"melu show <id-prefix>\" to view full details of a memory.",
+        memoryNotFoundByPrefix: "No memory found with ID prefix '{id}'",
+        multipleMemoryMatches: "Multiple memories matched. Please provide a more specific ID.",
+        deletedMemory: "Deleted: {summary}",
+        memoryAlreadyEmpty: "Memory is already empty",
+        confirmClearMemories: "Clear {count} memories? This cannot be undone (y/N): ",
+        clearedMemories: "Cleared {count} memories",
+        exportedTo: "Exported to: {path}",
+        sourceFileNotFound: "File not found: {path}",
+        importedMemories: "Imported {count} memories",
+        statusRunning: "Proxy status: running (PID: {pid}, port: {port})",
+        statusStopped: "Proxy status: stopped",
+        statusMemoryFile: "Memory file: {path}",
+        statusActiveMemories: "Active memories: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "Mirror source: {label}",
+        statusModelFile: "Model file: {status}",
+        statusDownloaded: "downloaded",
+        statusNotDownloaded: "not downloaded",
+        notSet: "Not set",
+        portInUse: "Port {port} is already in use. Stop the conflicting process or choose a different port.",
+        proxyStartupTimeout: "Proxy service startup timed out",
+        extractingConversationMemories: "[Melu] Extracting memories from {count} conversations...",
+        singleExtractionFailed: "[Melu] Failed to extract one queued item:",
+        extractedNewMemories: "[Melu] Extracted {count} new memories this run",
+        noNewMemories: "[Melu] No new memories this run",
+        runSummaryTitle: "[Melu] Run summary ({runId})",
+        runSummaryProcessed: "[Melu] Processed: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] Effective new memories: {count}",
+        runSummaryFailed: "[Melu] Failed: {count}",
+        runSummaryRemainingQueue: "[Melu] Remaining queue: {count}",
+        languagePromptTitle: "Select the display language for Melu:",
+        menuHint: "Use arrow keys to move, Enter to confirm.",
+        languagePromptInput: "Select a language:",
+        languagePromptRetry: "Please select a valid option.",
+        languageSet: "Display language: {language}",
+        mirrorPromptTitle: "Select the source for the GGUF embedding model:",
+        mirrorPromptInput: "Select a model source:",
+        mirrorPromptRetry: "Please select a valid option.",
+        mirrorHintHuggingFace: "Best for global network access",
+        mirrorHintModelScope: "Best for mainland China network access",
+        mirrorSelectionRequired: "A mirror source must be selected before model setup. Run `melu init --mirror huggingface` or `melu init --mirror modelscope`.",
+        embeddingDownload: "[Melu] Downloading embedding model: {file}",
+        labelSource: "[Melu] Source: {label}",
+        labelSavedTo: "[Melu] Saving to: {path}",
+        downloadProgressDownloadingTo: "Downloading to",
+        downloadProgressDownloadedTo: "Downloaded to",
+        modelAlreadyAvailable: "[Melu] Embedding model already found: {path}",
+        modelSkipDownload: "[Melu] Skipping download.",
+        runtimeBinaryUnavailable: "No prebuilt llama.cpp runtime is available on this platform. Melu does not auto-compile local native dependencies. Use Node 20+ on macOS, Linux, or Windows arm64/x64.",
+        memoryUpdated: "[Melu] Memory updated: '{summary}' replaced '{previous}'",
+        memoryNew: "[Melu] New memory: [{category}] {summary}",
+        embeddingFailed: "[Melu] Embedding failed:",
+        claudePExtracting: "[Melu:DEBUG] Extracting memory via claude -p",
+        claudePExitCode: "[Melu] claude -p exited with code {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] Failed to start claude -p: {message}",
+    },
+    "zh-CN": {
+        programDescription: "Melu - 透明 AI 记忆代理",
+        cmdInitDescription: "首次初始化：创建目录、配置和默认记忆文件",
+        cmdRunDescription: "带记忆启动任意 Agent",
+        cmdStopDescription: "停止后台代理服务",
+        cmdListDescription: "列出当前记忆条目",
+        cmdDeleteDescription: "按 ID 前缀删除某条记忆",
+        cmdClearDescription: "清空当前记忆（需确认）",
+        cmdExportDescription: "导出当前记忆为 .memory 文件",
+        cmdImportDescription: "从 .memory 文件导入记忆",
+        cmdStatusDescription: "查看服务状态、记忆数量和模型信息",
+        optMirrorDescription: "模型镜像源 (huggingface | modelscope)",
+        optMemoryDescription: "记忆文件",
+        optMemoryNameOrPathDescription: "记忆名称或路径",
+        optAllDescription: "包含已失效的记忆",
+        optYesDescription: "跳过确认",
+        optPortDescription: "代理端口",
+        optOutputDescription: "输出文件路径",
+        argCommandDescription: "要执行的命令",
+        initTitle: "Melu 初始化",
+        labelDirectory: "目录",
+        labelConfig: "配置",
+        labelMemory: "记忆",
+        initComplete: "初始化完成！",
+        labelMirrorSource: "镜像源",
+        embeddingModelReady: "Embedding 模型已准备完成。",
+        usageRunClaude: "使用: melu run -- claude",
+        runProxy: "代理",
+        runMemory: "记忆",
+        memoryExtractionFailed: "[Melu] 记忆提取失败:",
+        proxyNotRunning: "代理服务未在运行",
+        proxyStopped: "代理服务已停止 (PID: {pid})",
+        proxyAlreadyGone: "代理服务已不存在",
+        memoryFileNotFound: "记忆文件不存在: {path}",
+        noMemories: "暂无记忆",
+        memoriesTitle: "记忆 ({count} 条)",
+        tableType: "类型",
+        tableSubject: "主题",
+        tableSummary: "摘要",
+        tableCreatedAt: "创建时间",
+        tableStatus: "状态",
+        listShowHint: "使用 \"melu show <ID前缀>\" 查看记忆详情。",
+        memoryNotFoundByPrefix: "未找到 ID 以 '{id}' 开头的记忆",
+        multipleMemoryMatches: "匹配到多条记忆，请提供更精确的 ID。",
+        deletedMemory: "已删除: {summary}",
+        memoryAlreadyEmpty: "记忆已经是空的",
+        confirmClearMemories: "确认清空 {count} 条记忆？此操作不可恢复 (y/N): ",
+        clearedMemories: "已清空 {count} 条记忆",
+        exportedTo: "已导出到: {path}",
+        sourceFileNotFound: "文件不存在: {path}",
+        importedMemories: "已导入 {count} 条记忆",
+        statusRunning: "代理状态: 运行中 (PID: {pid}, 端口: {port})",
+        statusStopped: "代理状态: 未运行",
+        statusMemoryFile: "记忆文件: {path}",
+        statusActiveMemories: "活跃记忆: {count} 条",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "镜像源: {label}",
+        statusModelFile: "模型文件: {status}",
+        statusDownloaded: "已下载",
+        statusNotDownloaded: "未下载",
+        notSet: "未设置",
+        portInUse: "端口 {port} 已被占用，请先关闭占用进程或换一个端口。",
+        proxyStartupTimeout: "代理服务启动超时",
+        extractingConversationMemories: "[Melu] 正在提取 {count} 条对话的记忆...",
+        singleExtractionFailed: "[Melu] 提取单条失败:",
+        extractedNewMemories: "[Melu] 本次提取 {count} 条新记忆",
+        noNewMemories: "[Melu] 本次无新记忆",
+        runSummaryTitle: "[Melu] 运行摘要 ({runId})",
+        runSummaryProcessed: "[Melu] 已处理: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] 有效新记忆: {count}",
+        runSummaryFailed: "[Melu] 失败: {count}",
+        runSummaryRemainingQueue: "[Melu] 剩余队列: {count}",
+        languagePromptTitle: "请选择 Melu 的显示语言：",
+        menuHint: "使用方向键切换，按 Enter 确认。",
+        languagePromptInput: "请选择语言：",
+        languagePromptRetry: "请选择有效选项。",
+        languageSet: "显示语言: {language}",
+        mirrorPromptTitle: "请选择 GGUF embedding 模型的来源：",
+        mirrorPromptInput: "请选择模型来源：",
+        mirrorPromptRetry: "请选择有效选项。",
+        mirrorHintHuggingFace: "适合全球网络环境",
+        mirrorHintModelScope: "适合中国大陆网络环境",
+        mirrorSelectionRequired: "首次准备模型前需要先选择镜像源。请运行 `melu init --mirror huggingface` 或 `melu init --mirror modelscope`。",
+        embeddingDownload: "[Melu] 下载 embedding 模型: {file}",
+        labelSource: "[Melu] 来源: {label}",
+        labelSavedTo: "[Melu] 保存到: {path}",
+        downloadProgressDownloadingTo: "下载到",
+        downloadProgressDownloadedTo: "已下载到",
+        modelAlreadyAvailable: "[Melu] 已检测到 embedding 模型: {path}",
+        modelSkipDownload: "[Melu] 跳过下载。",
+        runtimeBinaryUnavailable: "当前平台没有可用的 llama.cpp 预编译运行时。Melu 默认不会在用户机器上自动编译本地依赖。请使用 Node 20+，并在 macOS、Linux 或 Windows 的 arm64/x64 环境运行。",
+        memoryUpdated: "[Melu] 记忆更新: '{summary}' 取代 '{previous}'",
+        memoryNew: "[Melu] 新记忆: [{category}] {summary}",
+        embeddingFailed: "[Melu] Embedding 失败:",
+        claudePExtracting: "[Melu:DEBUG] 通过 claude -p 提取记忆",
+        claudePExitCode: "[Melu] claude -p 退出码: {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] claude -p 启动失败: {message}",
+    },
+    "zh-TW": {
+        programDescription: "Melu - 透明 AI 記憶代理",
+        cmdInitDescription: "首次初始化：建立目錄、設定與預設記憶檔案",
+        cmdRunDescription: "帶著記憶啟動任意 Agent",
+        cmdStopDescription: "停止背景代理服務",
+        cmdListDescription: "列出目前的記憶項目",
+        cmdDeleteDescription: "依 ID 前綴刪除記憶",
+        cmdClearDescription: "清空目前記憶（需確認）",
+        cmdExportDescription: "將目前記憶匯出為 .memory 檔案",
+        cmdImportDescription: "從 .memory 檔案匯入記憶",
+        cmdStatusDescription: "查看服務狀態、記憶數量與模型資訊",
+        optMirrorDescription: "模型鏡像來源 (huggingface | modelscope)",
+        optMemoryDescription: "記憶檔案",
+        optMemoryNameOrPathDescription: "記憶名稱或路徑",
+        optAllDescription: "包含已失效記憶",
+        optYesDescription: "跳過確認",
+        optPortDescription: "代理埠",
+        optOutputDescription: "輸出檔案路徑",
+        argCommandDescription: "要執行的命令",
+        initTitle: "Melu 初始化",
+        labelDirectory: "目錄",
+        labelConfig: "設定",
+        labelMemory: "記憶",
+        initComplete: "初始化完成！",
+        labelMirrorSource: "鏡像來源",
+        embeddingModelReady: "Embedding 模型已準備完成。",
+        usageRunClaude: "用法: melu run -- claude",
+        runProxy: "代理",
+        runMemory: "記憶",
+        memoryExtractionFailed: "[Melu] 記憶提取失敗:",
+        proxyNotRunning: "代理服務尚未運行",
+        proxyStopped: "代理服務已停止 (PID: {pid})",
+        proxyAlreadyGone: "代理服務已不存在",
+        memoryFileNotFound: "找不到記憶檔案: {path}",
+        noMemories: "目前沒有記憶",
+        memoriesTitle: "記憶（{count} 條）",
+        tableType: "類型",
+        tableSubject: "主題",
+        tableSummary: "摘要",
+        tableCreatedAt: "建立時間",
+        tableStatus: "狀態",
+        listShowHint: "使用 \"melu show <ID前綴>\" 查看記憶詳情。",
+        memoryNotFoundByPrefix: "找不到 ID 以前綴 '{id}' 開頭的記憶",
+        multipleMemoryMatches: "找到多條相符記憶，請提供更精確的 ID。",
+        deletedMemory: "已刪除: {summary}",
+        memoryAlreadyEmpty: "記憶已經是空的",
+        confirmClearMemories: "確認清空 {count} 條記憶？此操作無法復原 (y/N): ",
+        clearedMemories: "已清空 {count} 條記憶",
+        exportedTo: "已匯出到: {path}",
+        sourceFileNotFound: "找不到檔案: {path}",
+        importedMemories: "已匯入 {count} 條記憶",
+        statusRunning: "代理狀態: 運行中 (PID: {pid}, 埠: {port})",
+        statusStopped: "代理狀態: 未運行",
+        statusMemoryFile: "記憶檔案: {path}",
+        statusActiveMemories: "有效記憶: {count} 條",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "鏡像來源: {label}",
+        statusModelFile: "模型檔案: {status}",
+        statusDownloaded: "已下載",
+        statusNotDownloaded: "未下載",
+        notSet: "未設定",
+        portInUse: "埠 {port} 已被占用，請先關閉占用程序或改用其他埠。",
+        proxyStartupTimeout: "代理服務啟動逾時",
+        extractingConversationMemories: "[Melu] 正在提取 {count} 條對話記憶...",
+        singleExtractionFailed: "[Melu] 單條提取失敗:",
+        extractedNewMemories: "[Melu] 本次提取了 {count} 條新記憶",
+        noNewMemories: "[Melu] 本次沒有新記憶",
+        runSummaryTitle: "[Melu] 運行摘要 ({runId})",
+        runSummaryProcessed: "[Melu] 已處理: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] 有效新記憶: {count}",
+        runSummaryFailed: "[Melu] 失敗: {count}",
+        runSummaryRemainingQueue: "[Melu] 剩餘佇列: {count}",
+        languagePromptTitle: "請選擇 Melu 的顯示語言：",
+        menuHint: "使用方向鍵切換，按 Enter 確認。",
+        languagePromptInput: "請選擇語言：",
+        languagePromptRetry: "請選擇有效選項。",
+        languageSet: "顯示語言: {language}",
+        mirrorPromptTitle: "請選擇 GGUF embedding 模型來源：",
+        mirrorPromptInput: "請選擇模型來源：",
+        mirrorPromptRetry: "請選擇有效選項。",
+        mirrorHintHuggingFace: "適合全球網路環境",
+        mirrorHintModelScope: "適合中國大陸網路環境",
+        mirrorSelectionRequired: "首次準備模型前需要先選擇鏡像來源。請執行 `melu init --mirror huggingface` 或 `melu init --mirror modelscope`。",
+        embeddingDownload: "[Melu] 下載 embedding 模型: {file}",
+        labelSource: "[Melu] 來源: {label}",
+        labelSavedTo: "[Melu] 儲存到: {path}",
+        downloadProgressDownloadingTo: "下載到",
+        downloadProgressDownloadedTo: "已下載到",
+        modelAlreadyAvailable: "[Melu] 已偵測到 embedding 模型: {path}",
+        modelSkipDownload: "[Melu] 略過下載。",
+        runtimeBinaryUnavailable: "目前平台沒有可用的 llama.cpp 預編譯執行環境。Melu 不會自動在使用者機器上編譯本地原生依賴。請使用 Node 20+，並在 macOS、Linux 或 Windows 的 arm64/x64 環境運行。",
+        memoryUpdated: "[Melu] 記憶已更新: '{summary}' 取代 '{previous}'",
+        memoryNew: "[Melu] 新記憶: [{category}] {summary}",
+        embeddingFailed: "[Melu] Embedding 失敗:",
+        claudePExtracting: "[Melu:DEBUG] 透過 claude -p 提取記憶",
+        claudePExitCode: "[Melu] claude -p 結束碼: {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] 無法啟動 claude -p: {message}",
+    },
+    ja: {
+        programDescription: "Melu - 透過的な AI メモリプロキシ",
+        cmdInitDescription: "初期設定: ディレクトリ、設定、既定メモリを作成",
+        cmdRunDescription: "永続メモリ付きで任意の Agent を起動",
+        cmdStopDescription: "バックグラウンドのプロキシサービスを停止",
+        cmdListDescription: "現在のメモリエントリを一覧表示",
+        cmdDeleteDescription: "ID プレフィックスでメモリを削除",
+        cmdClearDescription: "現在のメモリを消去（確認あり）",
+        cmdExportDescription: "現在のメモリを .memory ファイルとして書き出す",
+        cmdImportDescription: ".memory ファイルからメモリを読み込む",
+        cmdStatusDescription: "サービス状態、メモリ数、モデル情報を表示",
+        optMirrorDescription: "モデルのミラー元 (huggingface | modelscope)",
+        optMemoryDescription: "メモリファイル",
+        optMemoryNameOrPathDescription: "メモリ名またはパス",
+        optAllDescription: "無効なメモリも含める",
+        optYesDescription: "確認を省略",
+        optPortDescription: "プロキシポート",
+        optOutputDescription: "出力ファイルのパス",
+        argCommandDescription: "実行するコマンド",
+        initTitle: "Melu セットアップ",
+        labelDirectory: "ディレクトリ",
+        labelConfig: "設定",
+        labelMemory: "メモリ",
+        initComplete: "セットアップが完了しました。",
+        labelMirrorSource: "ミラー元",
+        embeddingModelReady: "Embedding モデルの準備ができました。",
+        usageRunClaude: "使い方: melu run -- claude",
+        runProxy: "プロキシ",
+        runMemory: "メモリ",
+        memoryExtractionFailed: "[Melu] メモリ抽出に失敗しました:",
+        proxyNotRunning: "プロキシサービスは実行されていません",
+        proxyStopped: "プロキシサービスを停止しました (PID: {pid})",
+        proxyAlreadyGone: "プロキシサービスはすでに存在しません",
+        memoryFileNotFound: "メモリファイルが見つかりません: {path}",
+        noMemories: "メモリはまだありません",
+        memoriesTitle: "メモリ ({count})",
+        tableType: "種類",
+        tableSubject: "件名",
+        tableSummary: "要約",
+        tableCreatedAt: "作成日時",
+        tableStatus: "状態",
+        listShowHint: "\"melu show <IDプレフィックス>\" でメモリの詳細を表示できます。",
+        memoryNotFoundByPrefix: "ID が '{id}' で始まるメモリは見つかりません",
+        multipleMemoryMatches: "複数のメモリが一致しました。より具体的な ID を指定してください。",
+        deletedMemory: "削除しました: {summary}",
+        memoryAlreadyEmpty: "メモリはすでに空です",
+        confirmClearMemories: "{count} 件のメモリを削除しますか？この操作は元に戻せません (y/N): ",
+        clearedMemories: "{count} 件のメモリを削除しました",
+        exportedTo: "書き出し先: {path}",
+        sourceFileNotFound: "ファイルが見つかりません: {path}",
+        importedMemories: "{count} 件のメモリを読み込みました",
+        statusRunning: "プロキシ状態: 実行中 (PID: {pid}, ポート: {port})",
+        statusStopped: "プロキシ状態: 停止中",
+        statusMemoryFile: "メモリファイル: {path}",
+        statusActiveMemories: "有効メモリ: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "ミラー元: {label}",
+        statusModelFile: "モデルファイル: {status}",
+        statusDownloaded: "ダウンロード済み",
+        statusNotDownloaded: "未ダウンロード",
+        notSet: "未設定",
+        portInUse: "ポート {port} はすでに使用されています。競合するプロセスを停止するか、別のポートを指定してください。",
+        proxyStartupTimeout: "プロキシサービスの起動がタイムアウトしました",
+        extractingConversationMemories: "[Melu] {count} 件の会話からメモリを抽出しています...",
+        singleExtractionFailed: "[Melu] 1 件の抽出に失敗しました:",
+        extractedNewMemories: "[Melu] 今回新たに {count} 件のメモリを抽出しました",
+        noNewMemories: "[Melu] 今回新しいメモリはありませんでした",
+        runSummaryTitle: "[Melu] 実行サマリー ({runId})",
+        runSummaryProcessed: "[Melu] 処理済み: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] 有効な新メモリ: {count}",
+        runSummaryFailed: "[Melu] 失敗: {count}",
+        runSummaryRemainingQueue: "[Melu] 残りキュー: {count}",
+        languagePromptTitle: "Melu の表示言語を選択してください:",
+        menuHint: "矢印キーで移動し、Enter で確定します。",
+        languagePromptInput: "言語を選択してください:",
+        languagePromptRetry: "有効な選択肢を選んでください。",
+        languageSet: "表示言語: {language}",
+        mirrorPromptTitle: "GGUF embedding モデルの取得元を選択してください:",
+        mirrorPromptInput: "モデルの取得元を選択してください:",
+        mirrorPromptRetry: "有効な選択肢を選んでください。",
+        mirrorHintHuggingFace: "グローバルなネットワーク環境向け",
+        mirrorHintModelScope: "中国本土のネットワーク環境向け",
+        mirrorSelectionRequired: "モデル準備の前にミラー元の選択が必要です。`melu init --mirror huggingface` または `melu init --mirror modelscope` を実行してください。",
+        embeddingDownload: "[Melu] Embedding モデルをダウンロードしています: {file}",
+        labelSource: "[Melu] 取得元: {label}",
+        labelSavedTo: "[Melu] 保存先: {path}",
+        downloadProgressDownloadingTo: "ダウンロード先",
+        downloadProgressDownloadedTo: "ダウンロード済み",
+        modelAlreadyAvailable: "[Melu] 既存の embedding モデルを検出しました: {path}",
+        modelSkipDownload: "[Melu] ダウンロードをスキップします。",
+        runtimeBinaryUnavailable: "このプラットフォームでは利用可能な事前ビルド済み llama.cpp ランタイムがありません。Melu はローカルのネイティブ依存関係を自動コンパイルしません。Node 20+ を使用し、macOS / Linux / Windows の arm64/x64 環境で実行してください。",
+        memoryUpdated: "[Melu] メモリを更新しました: '{summary}' が '{previous}' を置き換えました",
+        memoryNew: "[Melu] 新しいメモリ: [{category}] {summary}",
+        embeddingFailed: "[Melu] Embedding に失敗しました:",
+        claudePExtracting: "[Melu:DEBUG] claude -p でメモリを抽出しています",
+        claudePExitCode: "[Melu] claude -p の終了コード: {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] claude -p の起動に失敗しました: {message}",
+    },
+    ko: {
+        programDescription: "Melu - 투명한 AI 메모리 프록시",
+        cmdInitDescription: "초기 설정: 디렉터리, 설정, 기본 메모리 파일 생성",
+        cmdRunDescription: "지속 메모리와 함께 Agent 실행",
+        cmdStopDescription: "백그라운드 프록시 서비스 중지",
+        cmdListDescription: "현재 메모리 항목 표시",
+        cmdDeleteDescription: "ID 접두사로 메모리 삭제",
+        cmdClearDescription: "현재 메모리 비우기(확인 필요)",
+        cmdExportDescription: "현재 메모리를 .memory 파일로 내보내기",
+        cmdImportDescription: ".memory 파일에서 메모리 가져오기",
+        cmdStatusDescription: "서비스 상태, 메모리 수, 모델 정보 표시",
+        optMirrorDescription: "모델 미러 소스 (huggingface | modelscope)",
+        optMemoryDescription: "메모리 파일",
+        optMemoryNameOrPathDescription: "메모리 이름 또는 경로",
+        optAllDescription: "비활성 메모리 포함",
+        optYesDescription: "확인 건너뛰기",
+        optPortDescription: "프록시 포트",
+        optOutputDescription: "출력 파일 경로",
+        argCommandDescription: "실행할 명령",
+        initTitle: "Melu 설정",
+        labelDirectory: "디렉터리",
+        labelConfig: "설정",
+        labelMemory: "메모리",
+        initComplete: "설정이 완료되었습니다.",
+        labelMirrorSource: "미러 소스",
+        embeddingModelReady: "Embedding 모델이 준비되었습니다.",
+        usageRunClaude: "사용법: melu run -- claude",
+        runProxy: "프록시",
+        runMemory: "메모리",
+        memoryExtractionFailed: "[Melu] 메모리 추출 실패:",
+        proxyNotRunning: "프록시 서비스가 실행 중이 아닙니다",
+        proxyStopped: "프록시 서비스가 중지되었습니다 (PID: {pid})",
+        proxyAlreadyGone: "프록시 서비스가 이미 종료되었습니다",
+        memoryFileNotFound: "메모리 파일을 찾을 수 없습니다: {path}",
+        noMemories: "메모리가 없습니다",
+        memoriesTitle: "메모리 ({count})",
+        tableType: "유형",
+        tableSubject: "주제",
+        tableSummary: "요약",
+        tableCreatedAt: "생성 시간",
+        tableStatus: "상태",
+        listShowHint: "\"melu show <ID접두사>\" 로 메모리 세부 정보를 확인할 수 있습니다.",
+        memoryNotFoundByPrefix: "ID가 '{id}'로 시작하는 메모리를 찾을 수 없습니다",
+        multipleMemoryMatches: "여러 메모리가 일치합니다. 더 구체적인 ID를 입력하세요.",
+        deletedMemory: "삭제됨: {summary}",
+        memoryAlreadyEmpty: "메모리가 이미 비어 있습니다",
+        confirmClearMemories: "{count}개의 메모리를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다 (y/N): ",
+        clearedMemories: "{count}개의 메모리를 삭제했습니다",
+        exportedTo: "내보낸 위치: {path}",
+        sourceFileNotFound: "파일을 찾을 수 없습니다: {path}",
+        importedMemories: "{count}개의 메모리를 가져왔습니다",
+        statusRunning: "프록시 상태: 실행 중 (PID: {pid}, 포트: {port})",
+        statusStopped: "프록시 상태: 중지됨",
+        statusMemoryFile: "메모리 파일: {path}",
+        statusActiveMemories: "활성 메모리: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "미러 소스: {label}",
+        statusModelFile: "모델 파일: {status}",
+        statusDownloaded: "다운로드됨",
+        statusNotDownloaded: "다운로드되지 않음",
+        notSet: "설정되지 않음",
+        portInUse: "포트 {port}가 이미 사용 중입니다. 충돌하는 프로세스를 종료하거나 다른 포트를 선택하세요.",
+        proxyStartupTimeout: "프록시 서비스 시작 시간이 초과되었습니다",
+        extractingConversationMemories: "[Melu] {count}개의 대화에서 메모리를 추출하는 중...",
+        singleExtractionFailed: "[Melu] 대기 항목 1개 추출 실패:",
+        extractedNewMemories: "[Melu] 이번 실행에서 {count}개의 새 메모리를 추출했습니다",
+        noNewMemories: "[Melu] 이번 실행에서는 새 메모리가 없습니다",
+        runSummaryTitle: "[Melu] 실행 요약 ({runId})",
+        runSummaryProcessed: "[Melu] 처리됨: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] 유효한 새 메모리: {count}",
+        runSummaryFailed: "[Melu] 실패: {count}",
+        runSummaryRemainingQueue: "[Melu] 남은 큐: {count}",
+        languagePromptTitle: "Melu 표시 언어를 선택하세요:",
+        menuHint: "방향키로 이동하고 Enter로 선택하세요.",
+        languagePromptInput: "언어를 선택하세요:",
+        languagePromptRetry: "유효한 항목을 선택하세요.",
+        languageSet: "표시 언어: {language}",
+        mirrorPromptTitle: "GGUF embedding 모델의 소스를 선택하세요:",
+        mirrorPromptInput: "모델 소스를 선택하세요:",
+        mirrorPromptRetry: "유효한 항목을 선택하세요.",
+        mirrorHintHuggingFace: "전 세계 네트워크 환경에 적합",
+        mirrorHintModelScope: "중국 본토 네트워크 환경에 적합",
+        mirrorSelectionRequired: "모델 설정 전에 미러 소스를 선택해야 합니다. `melu init --mirror huggingface` 또는 `melu init --mirror modelscope`를 실행하세요.",
+        embeddingDownload: "[Melu] Embedding 모델 다운로드 중: {file}",
+        labelSource: "[Melu] 소스: {label}",
+        labelSavedTo: "[Melu] 저장 위치: {path}",
+        downloadProgressDownloadingTo: "다운로드 위치",
+        downloadProgressDownloadedTo: "다운로드 완료 위치",
+        modelAlreadyAvailable: "[Melu] 기존 embedding 모델을 찾았습니다: {path}",
+        modelSkipDownload: "[Melu] 다운로드를 건너뜁니다.",
+        runtimeBinaryUnavailable: "이 플랫폼에서는 사용할 수 있는 사전 빌드된 llama.cpp 런타임이 없습니다. Melu는 로컬 네이티브 의존성을 자동으로 컴파일하지 않습니다. Node 20+ 및 macOS / Linux / Windows arm64/x64 환경을 사용하세요.",
+        memoryUpdated: "[Melu] 메모리 업데이트: '{summary}'가 '{previous}'를 대체했습니다",
+        memoryNew: "[Melu] 새 메모리: [{category}] {summary}",
+        embeddingFailed: "[Melu] Embedding 실패:",
+        claudePExtracting: "[Melu:DEBUG] claude -p로 메모리를 추출하는 중",
+        claudePExitCode: "[Melu] claude -p 종료 코드: {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] claude -p 시작 실패: {message}",
+    },
+    fr: {
+        programDescription: "Melu - proxy de mémoire IA transparent",
+        cmdInitDescription: "Configuration initiale : créer les dossiers, la config et la mémoire par défaut",
+        cmdRunDescription: "Exécuter un agent avec mémoire persistante",
+        cmdStopDescription: "Arrêter le service proxy en arrière-plan",
+        cmdListDescription: "Lister les entrées mémoire actuelles",
+        cmdDeleteDescription: "Supprimer une mémoire via son préfixe d'ID",
+        cmdClearDescription: "Vider la mémoire actuelle (avec confirmation)",
+        cmdExportDescription: "Exporter la mémoire actuelle vers un fichier .memory",
+        cmdImportDescription: "Importer des mémoires depuis un fichier .memory",
+        cmdStatusDescription: "Afficher l'état du service, le nombre de mémoires et les infos du modèle",
+        optMirrorDescription: "Source miroir du modèle (huggingface | modelscope)",
+        optMemoryDescription: "Fichier mémoire",
+        optMemoryNameOrPathDescription: "Nom ou chemin de la mémoire",
+        optAllDescription: "Inclure les mémoires inactives",
+        optYesDescription: "Ignorer la confirmation",
+        optPortDescription: "Port du proxy",
+        optOutputDescription: "Chemin du fichier de sortie",
+        argCommandDescription: "Commande à exécuter",
+        initTitle: "Configuration de Melu",
+        labelDirectory: "Répertoire",
+        labelConfig: "Config",
+        labelMemory: "Mémoire",
+        initComplete: "Configuration terminée.",
+        labelMirrorSource: "Source miroir",
+        embeddingModelReady: "Le modèle d'embedding est prêt.",
+        usageRunClaude: "Utilisation : melu run -- claude",
+        runProxy: "Proxy",
+        runMemory: "Mémoire",
+        memoryExtractionFailed: "[Melu] Échec de l'extraction de mémoire :",
+        proxyNotRunning: "Le service proxy n'est pas en cours d'exécution",
+        proxyStopped: "Service proxy arrêté (PID : {pid})",
+        proxyAlreadyGone: "Le service proxy n'existe plus",
+        memoryFileNotFound: "Fichier mémoire introuvable : {path}",
+        noMemories: "Aucune mémoire pour le moment",
+        memoriesTitle: "Mémoires ({count})",
+        tableType: "Type",
+        tableSubject: "Sujet",
+        tableSummary: "Résumé",
+        tableCreatedAt: "Créé le",
+        tableStatus: "État",
+        listShowHint: "Utilisez \"melu show <préfixe-ID>\" pour voir les détails d'une mémoire.",
+        memoryNotFoundByPrefix: "Aucune mémoire trouvée avec le préfixe d'ID '{id}'",
+        multipleMemoryMatches: "Plusieurs mémoires correspondent. Veuillez fournir un ID plus précis.",
+        deletedMemory: "Supprimé : {summary}",
+        memoryAlreadyEmpty: "La mémoire est déjà vide",
+        confirmClearMemories: "Supprimer {count} mémoires ? Cette action est irréversible (y/N) : ",
+        clearedMemories: "{count} mémoires supprimées",
+        exportedTo: "Exporté vers : {path}",
+        sourceFileNotFound: "Fichier introuvable : {path}",
+        importedMemories: "{count} mémoires importées",
+        statusRunning: "État du proxy : en cours (PID : {pid}, port : {port})",
+        statusStopped: "État du proxy : arrêté",
+        statusMemoryFile: "Fichier mémoire : {path}",
+        statusActiveMemories: "Mémoires actives : {count}",
+        statusEmbedding: "Embedding : {model}",
+        statusMirrorSource: "Source miroir : {label}",
+        statusModelFile: "Fichier modèle : {status}",
+        statusDownloaded: "téléchargé",
+        statusNotDownloaded: "non téléchargé",
+        notSet: "non défini",
+        portInUse: "Le port {port} est déjà utilisé. Arrêtez le processus en conflit ou choisissez un autre port.",
+        proxyStartupTimeout: "Délai de démarrage du service proxy dépassé",
+        extractingConversationMemories: "[Melu] Extraction des mémoires à partir de {count} conversations...",
+        singleExtractionFailed: "[Melu] Échec de l'extraction d'un élément en attente :",
+        extractedNewMemories: "[Melu] {count} nouvelles mémoires extraites lors de cette exécution",
+        noNewMemories: "[Melu] Aucune nouvelle mémoire lors de cette exécution",
+        runSummaryTitle: "[Melu] résumé d'exécution ({runId})",
+        runSummaryProcessed: "[Melu] traités : {count}",
+        runSummaryEffectiveNewMemories: "[Melu] nouvelles mémoires utiles : {count}",
+        runSummaryFailed: "[Melu] échecs : {count}",
+        runSummaryRemainingQueue: "[Melu] file restante : {count}",
+        languagePromptTitle: "Sélectionnez la langue d'affichage de Melu :",
+        menuHint: "Utilisez les flèches pour naviguer, puis Entrée pour confirmer.",
+        languagePromptInput: "Sélectionnez une langue :",
+        languagePromptRetry: "Veuillez sélectionner une option valide.",
+        languageSet: "Langue d'affichage : {language}",
+        mirrorPromptTitle: "Sélectionnez la source du modèle GGUF d'embedding :",
+        mirrorPromptInput: "Sélectionnez une source de modèle :",
+        mirrorPromptRetry: "Veuillez sélectionner une option valide.",
+        mirrorHintHuggingFace: "Recommandé pour un accès réseau mondial",
+        mirrorHintModelScope: "Recommandé pour le réseau de Chine continentale",
+        mirrorSelectionRequired: "Une source miroir doit être choisie avant la configuration du modèle. Exécutez `melu init --mirror huggingface` ou `melu init --mirror modelscope`.",
+        embeddingDownload: "[Melu] Téléchargement du modèle d'embedding : {file}",
+        labelSource: "[Melu] Source : {label}",
+        labelSavedTo: "[Melu] Enregistrement dans : {path}",
+        downloadProgressDownloadingTo: "Téléchargement vers",
+        downloadProgressDownloadedTo: "Téléchargé vers",
+        modelAlreadyAvailable: "[Melu] Modèle d'embedding déjà détecté : {path}",
+        modelSkipDownload: "[Melu] Téléchargement ignoré.",
+        runtimeBinaryUnavailable: "Aucun runtime llama.cpp précompilé n'est disponible sur cette plateforme. Melu ne compile pas automatiquement les dépendances natives locales. Utilisez Node 20+ sur macOS, Linux ou Windows arm64/x64.",
+        memoryUpdated: "[Melu] Mémoire mise à jour : '{summary}' a remplacé '{previous}'",
+        memoryNew: "[Melu] Nouvelle mémoire : [{category}] {summary}",
+        embeddingFailed: "[Melu] Échec de l'embedding :",
+        claudePExtracting: "[Melu:DEBUG] Extraction de mémoire via claude -p",
+        claudePExitCode: "[Melu] Code de sortie de claude -p : {code}, stderr : {stderr}",
+        claudePStartFailed: "[Melu] Impossible de démarrer claude -p : {message}",
+    },
+    ru: {
+        programDescription: "Melu - прозрачный прокси долговременной памяти ИИ",
+        cmdInitDescription: "Первичная настройка: создать каталоги, конфиг и файл памяти по умолчанию",
+        cmdRunDescription: "Запустить любой Agent с постоянной памятью",
+        cmdStopDescription: "Остановить фоновый прокси-сервис",
+        cmdListDescription: "Показать текущие записи памяти",
+        cmdDeleteDescription: "Удалить запись памяти по префиксу ID",
+        cmdClearDescription: "Очистить текущую память (с подтверждением)",
+        cmdExportDescription: "Экспортировать текущую память в файл .memory",
+        cmdImportDescription: "Импортировать память из файла .memory",
+        cmdStatusDescription: "Показать состояние сервиса, число записей памяти и сведения о модели",
+        optMirrorDescription: "Источник зеркала модели (huggingface | modelscope)",
+        optMemoryDescription: "Файл памяти",
+        optMemoryNameOrPathDescription: "Имя памяти или путь",
+        optAllDescription: "Включить неактивные записи памяти",
+        optYesDescription: "Пропустить подтверждение",
+        optPortDescription: "Порт прокси",
+        optOutputDescription: "Путь к выходному файлу",
+        argCommandDescription: "Команда для выполнения",
+        initTitle: "Настройка Melu",
+        labelDirectory: "Каталог",
+        labelConfig: "Конфиг",
+        labelMemory: "Память",
+        initComplete: "Настройка завершена.",
+        labelMirrorSource: "Источник зеркала",
+        embeddingModelReady: "Модель embedding готова.",
+        usageRunClaude: "Использование: melu run -- claude",
+        runProxy: "Прокси",
+        runMemory: "Память",
+        memoryExtractionFailed: "[Melu] Не удалось извлечь память:",
+        proxyNotRunning: "Прокси-сервис не запущен",
+        proxyStopped: "Прокси-сервис остановлен (PID: {pid})",
+        proxyAlreadyGone: "Прокси-сервис уже не существует",
+        memoryFileNotFound: "Файл памяти не найден: {path}",
+        noMemories: "Память пока пуста",
+        memoriesTitle: "Память ({count})",
+        tableType: "Тип",
+        tableSubject: "Тема",
+        tableSummary: "Сводка",
+        tableCreatedAt: "Создано",
+        tableStatus: "Статус",
+        listShowHint: "Используйте \"melu show <префикс-ID>\" для просмотра подробностей.",
+        memoryNotFoundByPrefix: "Запись памяти с префиксом ID '{id}' не найдена",
+        multipleMemoryMatches: "Найдено несколько совпадений. Укажите более точный ID.",
+        deletedMemory: "Удалено: {summary}",
+        memoryAlreadyEmpty: "Память уже пуста",
+        confirmClearMemories: "Очистить {count} записей памяти? Это действие нельзя отменить (y/N): ",
+        clearedMemories: "Очищено {count} записей памяти",
+        exportedTo: "Экспортировано в: {path}",
+        sourceFileNotFound: "Файл не найден: {path}",
+        importedMemories: "Импортировано {count} записей памяти",
+        statusRunning: "Статус прокси: запущен (PID: {pid}, порт: {port})",
+        statusStopped: "Статус прокси: остановлен",
+        statusMemoryFile: "Файл памяти: {path}",
+        statusActiveMemories: "Активных записей памяти: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "Источник зеркала: {label}",
+        statusModelFile: "Файл модели: {status}",
+        statusDownloaded: "загружен",
+        statusNotDownloaded: "не загружен",
+        notSet: "не задано",
+        portInUse: "Порт {port} уже занят. Остановите конфликтующий процесс или выберите другой порт.",
+        proxyStartupTimeout: "Истекло время запуска прокси-сервиса",
+        extractingConversationMemories: "[Melu] Извлечение памяти из {count} диалогов...",
+        singleExtractionFailed: "[Melu] Не удалось обработать один элемент очереди:",
+        extractedNewMemories: "[Melu] За этот запуск извлечено {count} новых записей памяти",
+        noNewMemories: "[Melu] В этом запуске новых записей памяти нет",
+        runSummaryTitle: "[Melu] сводка запуска ({runId})",
+        runSummaryProcessed: "[Melu] обработано: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] полезных новых записей: {count}",
+        runSummaryFailed: "[Melu] ошибок: {count}",
+        runSummaryRemainingQueue: "[Melu] очередь осталась: {count}",
+        languagePromptTitle: "Выберите язык интерфейса Melu:",
+        menuHint: "Используйте стрелки для выбора и Enter для подтверждения.",
+        languagePromptInput: "Выберите язык:",
+        languagePromptRetry: "Выберите корректный вариант.",
+        languageSet: "Язык интерфейса: {language}",
+        mirrorPromptTitle: "Выберите источник GGUF embedding модели:",
+        mirrorPromptInput: "Выберите источник модели:",
+        mirrorPromptRetry: "Выберите корректный вариант.",
+        mirrorHintHuggingFace: "Подходит для глобального доступа к сети",
+        mirrorHintModelScope: "Подходит для сетевой среды материкового Китая",
+        mirrorSelectionRequired: "Перед настройкой модели нужно выбрать источник зеркала. Выполните `melu init --mirror huggingface` или `melu init --mirror modelscope`.",
+        embeddingDownload: "[Melu] Загрузка embedding модели: {file}",
+        labelSource: "[Melu] Источник: {label}",
+        labelSavedTo: "[Melu] Сохранение в: {path}",
+        downloadProgressDownloadingTo: "Загрузка в",
+        downloadProgressDownloadedTo: "Загружено в",
+        modelAlreadyAvailable: "[Melu] Embedding модель уже найдена: {path}",
+        modelSkipDownload: "[Melu] Загрузка пропущена.",
+        runtimeBinaryUnavailable: "Для этой платформы нет доступного предсобранного runtime llama.cpp. Melu не компилирует локальные нативные зависимости автоматически. Используйте Node 20+ на macOS, Linux или Windows arm64/x64.",
+        memoryUpdated: "[Melu] Память обновлена: '{summary}' заменила '{previous}'",
+        memoryNew: "[Melu] Новая память: [{category}] {summary}",
+        embeddingFailed: "[Melu] Ошибка embedding:",
+        claudePExtracting: "[Melu:DEBUG] Извлечение памяти через claude -p",
+        claudePExitCode: "[Melu] Код выхода claude -p: {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] Не удалось запустить claude -p: {message}",
+    },
+    de: {
+        programDescription: "Melu - transparenter KI-Speicher-Proxy",
+        cmdInitDescription: "Ersteinrichtung: Verzeichnisse, Konfiguration und Standard-Speicherdatei erstellen",
+        cmdRunDescription: "Beliebigen Agent mit dauerhaftem Speicher ausführen",
+        cmdStopDescription: "Den Hintergrund-Proxy-Dienst beenden",
+        cmdListDescription: "Aktuelle Speichereinträge auflisten",
+        cmdDeleteDescription: "Einen Speichereintrag per ID-Präfix löschen",
+        cmdClearDescription: "Aktuellen Speicher leeren (mit Bestätigung)",
+        cmdExportDescription: "Aktuellen Speicher in eine .memory-Datei exportieren",
+        cmdImportDescription: "Speicher aus einer .memory-Datei importieren",
+        cmdStatusDescription: "Dienststatus, Anzahl der Erinnerungen und Modellinfos anzeigen",
+        optMirrorDescription: "Modell-Spiegelquelle (huggingface | modelscope)",
+        optMemoryDescription: "Speicherdatei",
+        optMemoryNameOrPathDescription: "Speichername oder Pfad",
+        optAllDescription: "Inaktive Erinnerungen einschließen",
+        optYesDescription: "Bestätigung überspringen",
+        optPortDescription: "Proxy-Port",
+        optOutputDescription: "Pfad der Ausgabedatei",
+        argCommandDescription: "Auszuführender Befehl",
+        initTitle: "Melu-Einrichtung",
+        labelDirectory: "Verzeichnis",
+        labelConfig: "Konfiguration",
+        labelMemory: "Speicher",
+        initComplete: "Einrichtung abgeschlossen!",
+        labelMirrorSource: "Spiegelquelle",
+        embeddingModelReady: "Das Embedding-Modell ist bereit.",
+        usageRunClaude: "Verwendung: melu run -- claude",
+        runProxy: "Proxy",
+        runMemory: "Speicher",
+        memoryExtractionFailed: "[Melu] Speicherauszug fehlgeschlagen:",
+        proxyNotRunning: "Der Proxy-Dienst läuft nicht",
+        proxyStopped: "Proxy-Dienst gestoppt (PID: {pid})",
+        proxyAlreadyGone: "Der Proxy-Dienst existiert nicht mehr",
+        memoryFileNotFound: "Speicherdatei nicht gefunden: {path}",
+        noMemories: "Noch keine Erinnerungen",
+        memoriesTitle: "Erinnerungen ({count})",
+        tableType: "Typ",
+        tableSubject: "Thema",
+        tableSummary: "Zusammenfassung",
+        tableCreatedAt: "Erstellt am",
+        tableStatus: "Status",
+        listShowHint: "Verwenden Sie \"melu show <ID-Präfix>\" für Details einer Erinnerung.",
+        memoryNotFoundByPrefix: "Keine Erinnerung mit ID-Präfix '{id}' gefunden",
+        multipleMemoryMatches: "Mehrere Erinnerungen gefunden. Bitte gib eine genauere ID an.",
+        deletedMemory: "Gelöscht: {summary}",
+        memoryAlreadyEmpty: "Der Speicher ist bereits leer",
+        confirmClearMemories: "{count} Erinnerungen löschen? Dieser Vorgang kann nicht rückgängig gemacht werden (y/N): ",
+        clearedMemories: "{count} Erinnerungen gelöscht",
+        exportedTo: "Exportiert nach: {path}",
+        sourceFileNotFound: "Datei nicht gefunden: {path}",
+        importedMemories: "{count} Erinnerungen importiert",
+        statusRunning: "Proxy-Status: läuft (PID: {pid}, Port: {port})",
+        statusStopped: "Proxy-Status: gestoppt",
+        statusMemoryFile: "Speicherdatei: {path}",
+        statusActiveMemories: "Aktive Erinnerungen: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "Spiegelquelle: {label}",
+        statusModelFile: "Modelldatei: {status}",
+        statusDownloaded: "heruntergeladen",
+        statusNotDownloaded: "nicht heruntergeladen",
+        notSet: "Nicht festgelegt",
+        portInUse: "Port {port} wird bereits verwendet. Beende den Konfliktprozess oder wähle einen anderen Port.",
+        proxyStartupTimeout: "Zeitüberschreitung beim Start des Proxy-Dienstes",
+        extractingConversationMemories: "[Melu] Extrahiere Erinnerungen aus {count} Unterhaltungen...",
+        singleExtractionFailed: "[Melu] Ein Eintrag aus der Warteschlange konnte nicht extrahiert werden:",
+        extractedNewMemories: "[Melu] Bei diesem Lauf wurden {count} neue Erinnerungen extrahiert",
+        noNewMemories: "[Melu] Bei diesem Lauf wurden keine neuen Erinnerungen extrahiert",
+        runSummaryTitle: "[Melu] Ausführungsübersicht ({runId})",
+        runSummaryProcessed: "[Melu] verarbeitet: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] nützliche neue Erinnerungen: {count}",
+        runSummaryFailed: "[Melu] fehlgeschlagen: {count}",
+        runSummaryRemainingQueue: "[Melu] verbleibende Warteschlange: {count}",
+        languagePromptTitle: "Wähle die Anzeigesprache für Melu:",
+        menuHint: "Mit den Pfeiltasten navigieren, mit Enter bestätigen.",
+        languagePromptInput: "Sprache auswählen:",
+        languagePromptRetry: "Bitte eine gültige Option auswählen.",
+        languageSet: "Anzeigesprache: {language}",
+        mirrorPromptTitle: "Wähle die Quelle für das GGUF-Embedding-Modell:",
+        mirrorPromptInput: "Modellquelle auswählen:",
+        mirrorPromptRetry: "Bitte eine gültige Option auswählen.",
+        mirrorHintHuggingFace: "Empfohlen für globale Netzwerke",
+        mirrorHintModelScope: "Empfohlen für Netzwerke auf dem chinesischen Festland",
+        mirrorSelectionRequired: "Vor der Modelleinrichtung muss eine Spiegelquelle gewählt werden. Führe `melu init --mirror huggingface` oder `melu init --mirror modelscope` aus.",
+        embeddingDownload: "[Melu] Embedding-Modell wird heruntergeladen: {file}",
+        labelSource: "[Melu] Quelle: {label}",
+        labelSavedTo: "[Melu] Speichern nach: {path}",
+        downloadProgressDownloadingTo: "Herunterladen nach",
+        downloadProgressDownloadedTo: "Heruntergeladen nach",
+        modelAlreadyAvailable: "[Melu] Embedding-Modell bereits gefunden: {path}",
+        modelSkipDownload: "[Melu] Download wird übersprungen.",
+        runtimeBinaryUnavailable: "Für diese Plattform ist keine vorgebaute llama.cpp-Laufzeit verfügbar. Melu kompiliert lokale native Abhängigkeiten nicht automatisch. Verwende Node 20+ unter macOS, Linux oder Windows arm64/x64.",
+        memoryUpdated: "[Melu] Erinnerung aktualisiert: '{summary}' ersetzte '{previous}'",
+        memoryNew: "[Melu] Neue Erinnerung: [{category}] {summary}",
+        embeddingFailed: "[Melu] Embedding fehlgeschlagen:",
+        claudePExtracting: "[Melu:DEBUG] Extrahiere Erinnerung über claude -p",
+        claudePExitCode: "[Melu] claude -p wurde mit Code {code} beendet, stderr: {stderr}",
+        claudePStartFailed: "[Melu] Start von claude -p fehlgeschlagen: {message}",
+    },
+    es: {
+        programDescription: "Melu - proxy transparente de memoria de IA",
+        cmdInitDescription: "Configuración inicial: crear directorios, configuración y archivo de memoria predeterminado",
+        cmdRunDescription: "Ejecutar cualquier agent con memoria persistente",
+        cmdStopDescription: "Detener el servicio proxy en segundo plano",
+        cmdListDescription: "Listar las entradas de memoria actuales",
+        cmdDeleteDescription: "Eliminar una memoria por prefijo de ID",
+        cmdClearDescription: "Vaciar la memoria actual (con confirmación)",
+        cmdExportDescription: "Exportar la memoria actual a un archivo .memory",
+        cmdImportDescription: "Importar memorias desde un archivo .memory",
+        cmdStatusDescription: "Mostrar estado del servicio, cantidad de memorias e información del modelo",
+        optMirrorDescription: "Origen espejo del modelo (huggingface | modelscope)",
+        optMemoryDescription: "Archivo de memoria",
+        optMemoryNameOrPathDescription: "Nombre o ruta de la memoria",
+        optAllDescription: "Incluir memorias inactivas",
+        optYesDescription: "Omitir confirmación",
+        optPortDescription: "Puerto del proxy",
+        optOutputDescription: "Ruta del archivo de salida",
+        argCommandDescription: "Comando a ejecutar",
+        initTitle: "Configuración de Melu",
+        labelDirectory: "Directorio",
+        labelConfig: "Configuración",
+        labelMemory: "Memoria",
+        initComplete: "¡Configuración completada!",
+        labelMirrorSource: "Origen espejo",
+        embeddingModelReady: "El modelo de embedding está listo.",
+        usageRunClaude: "Uso: melu run -- claude",
+        runProxy: "Proxy",
+        runMemory: "Memoria",
+        memoryExtractionFailed: "[Melu] Falló la extracción de memoria:",
+        proxyNotRunning: "El servicio proxy no está en ejecución",
+        proxyStopped: "Servicio proxy detenido (PID: {pid})",
+        proxyAlreadyGone: "El servicio proxy ya no existe",
+        memoryFileNotFound: "Archivo de memoria no encontrado: {path}",
+        noMemories: "Aún no hay memorias",
+        memoriesTitle: "Memorias ({count})",
+        tableType: "Tipo",
+        tableSubject: "Tema",
+        tableSummary: "Resumen",
+        tableCreatedAt: "Creado el",
+        tableStatus: "Estado",
+        listShowHint: "Use \"melu show <prefijo-ID>\" para ver los detalles de una memoria.",
+        memoryNotFoundByPrefix: "No se encontró ninguna memoria con el prefijo de ID '{id}'",
+        multipleMemoryMatches: "Se encontraron varias memorias. Proporciona un ID más específico.",
+        deletedMemory: "Eliminado: {summary}",
+        memoryAlreadyEmpty: "La memoria ya está vacía",
+        confirmClearMemories: "¿Eliminar {count} memorias? Esta acción no se puede deshacer (y/N): ",
+        clearedMemories: "Se eliminaron {count} memorias",
+        exportedTo: "Exportado a: {path}",
+        sourceFileNotFound: "Archivo no encontrado: {path}",
+        importedMemories: "Se importaron {count} memorias",
+        statusRunning: "Estado del proxy: en ejecución (PID: {pid}, puerto: {port})",
+        statusStopped: "Estado del proxy: detenido",
+        statusMemoryFile: "Archivo de memoria: {path}",
+        statusActiveMemories: "Memorias activas: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "Origen espejo: {label}",
+        statusModelFile: "Archivo del modelo: {status}",
+        statusDownloaded: "descargado",
+        statusNotDownloaded: "no descargado",
+        notSet: "No establecido",
+        portInUse: "El puerto {port} ya está en uso. Detén el proceso en conflicto o elige otro puerto.",
+        proxyStartupTimeout: "Tiempo de espera agotado al iniciar el servicio proxy",
+        extractingConversationMemories: "[Melu] Extrayendo memorias de {count} conversaciones...",
+        singleExtractionFailed: "[Melu] No se pudo extraer un elemento en cola:",
+        extractedNewMemories: "[Melu] En esta ejecución se extrajeron {count} memorias nuevas",
+        noNewMemories: "[Melu] No se extrajeron memorias nuevas en esta ejecución",
+        runSummaryTitle: "[Melu] resumen de ejecución ({runId})",
+        runSummaryProcessed: "[Melu] procesadas: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] nuevas memorias útiles: {count}",
+        runSummaryFailed: "[Melu] fallos: {count}",
+        runSummaryRemainingQueue: "[Melu] cola restante: {count}",
+        languagePromptTitle: "Selecciona el idioma de visualización de Melu:",
+        menuHint: "Usa las flechas para moverte y Enter para confirmar.",
+        languagePromptInput: "Selecciona un idioma:",
+        languagePromptRetry: "Selecciona una opción válida.",
+        languageSet: "Idioma de visualización: {language}",
+        mirrorPromptTitle: "Selecciona el origen del modelo GGUF de embedding:",
+        mirrorPromptInput: "Selecciona una fuente del modelo:",
+        mirrorPromptRetry: "Selecciona una opción válida.",
+        mirrorHintHuggingFace: "Recomendado para redes globales",
+        mirrorHintModelScope: "Recomendado para redes de China continental",
+        mirrorSelectionRequired: "Debes elegir un origen espejo antes de configurar el modelo. Ejecuta `melu init --mirror huggingface` o `melu init --mirror modelscope`.",
+        embeddingDownload: "[Melu] Descargando modelo de embedding: {file}",
+        labelSource: "[Melu] Origen: {label}",
+        labelSavedTo: "[Melu] Guardando en: {path}",
+        downloadProgressDownloadingTo: "Descargando en",
+        downloadProgressDownloadedTo: "Descargado en",
+        modelAlreadyAvailable: "[Melu] Modelo de embedding ya encontrado: {path}",
+        modelSkipDownload: "[Melu] Omitiendo descarga.",
+        runtimeBinaryUnavailable: "No hay un runtime precompilado de llama.cpp disponible para esta plataforma. Melu no compila automáticamente dependencias nativas locales. Usa Node 20+ en macOS, Linux o Windows arm64/x64.",
+        memoryUpdated: "[Melu] Memoria actualizada: '{summary}' reemplazó a '{previous}'",
+        memoryNew: "[Melu] Nueva memoria: [{category}] {summary}",
+        embeddingFailed: "[Melu] Falló el embedding:",
+        claudePExtracting: "[Melu:DEBUG] Extrayendo memoria mediante claude -p",
+        claudePExitCode: "[Melu] claude -p salió con código {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] No se pudo iniciar claude -p: {message}",
+    },
+    pt: {
+        programDescription: "Melu - proxy transparente de memória de IA",
+        cmdInitDescription: "Configuração inicial: criar diretórios, configuração e arquivo de memória padrão",
+        cmdRunDescription: "Executar qualquer agent com memória persistente",
+        cmdStopDescription: "Parar o serviço de proxy em segundo plano",
+        cmdListDescription: "Listar as entradas de memória atuais",
+        cmdDeleteDescription: "Excluir uma memória pelo prefixo do ID",
+        cmdClearDescription: "Limpar a memória atual (com confirmação)",
+        cmdExportDescription: "Exportar a memória atual para um arquivo .memory",
+        cmdImportDescription: "Importar memórias de um arquivo .memory",
+        cmdStatusDescription: "Mostrar status do serviço, quantidade de memórias e informações do modelo",
+        optMirrorDescription: "Fonte espelho do modelo (huggingface | modelscope)",
+        optMemoryDescription: "Arquivo de memória",
+        optMemoryNameOrPathDescription: "Nome ou caminho da memória",
+        optAllDescription: "Incluir memórias inativas",
+        optYesDescription: "Pular confirmação",
+        optPortDescription: "Porta do proxy",
+        optOutputDescription: "Caminho do arquivo de saída",
+        argCommandDescription: "Comando a executar",
+        initTitle: "Configuração do Melu",
+        labelDirectory: "Diretório",
+        labelConfig: "Configuração",
+        labelMemory: "Memória",
+        initComplete: "Configuração concluída!",
+        labelMirrorSource: "Fonte espelho",
+        embeddingModelReady: "O modelo de embedding está pronto.",
+        usageRunClaude: "Uso: melu run -- claude",
+        runProxy: "Proxy",
+        runMemory: "Memória",
+        memoryExtractionFailed: "[Melu] Falha na extração de memória:",
+        proxyNotRunning: "O serviço de proxy não está em execução",
+        proxyStopped: "Serviço de proxy parado (PID: {pid})",
+        proxyAlreadyGone: "O serviço de proxy não existe mais",
+        memoryFileNotFound: "Arquivo de memória não encontrado: {path}",
+        noMemories: "Ainda não há memórias",
+        memoriesTitle: "Memórias ({count})",
+        tableType: "Tipo",
+        tableSubject: "Assunto",
+        tableSummary: "Resumo",
+        tableCreatedAt: "Criado em",
+        tableStatus: "Status",
+        listShowHint: "Use \"melu show <prefixo-ID>\" para ver os detalhes de uma memória.",
+        memoryNotFoundByPrefix: "Nenhuma memória encontrada com o prefixo de ID '{id}'",
+        multipleMemoryMatches: "Várias memórias corresponderam. Forneça um ID mais específico.",
+        deletedMemory: "Excluído: {summary}",
+        memoryAlreadyEmpty: "A memória já está vazia",
+        confirmClearMemories: "Excluir {count} memórias? Esta ação não pode ser desfeita (y/N): ",
+        clearedMemories: "{count} memórias excluídas",
+        exportedTo: "Exportado para: {path}",
+        sourceFileNotFound: "Arquivo não encontrado: {path}",
+        importedMemories: "{count} memórias importadas",
+        statusRunning: "Status do proxy: em execução (PID: {pid}, porta: {port})",
+        statusStopped: "Status do proxy: parado",
+        statusMemoryFile: "Arquivo de memória: {path}",
+        statusActiveMemories: "Memórias ativas: {count}",
+        statusEmbedding: "Embedding: {model}",
+        statusMirrorSource: "Fonte espelho: {label}",
+        statusModelFile: "Arquivo do modelo: {status}",
+        statusDownloaded: "baixado",
+        statusNotDownloaded: "não baixado",
+        notSet: "Não definido",
+        portInUse: "A porta {port} já está em uso. Encerre o processo em conflito ou escolha outra porta.",
+        proxyStartupTimeout: "Tempo limite ao iniciar o serviço de proxy",
+        extractingConversationMemories: "[Melu] Extraindo memórias de {count} conversas...",
+        singleExtractionFailed: "[Melu] Falha ao extrair um item da fila:",
+        extractedNewMemories: "[Melu] Nesta execução foram extraídas {count} novas memórias",
+        noNewMemories: "[Melu] Nenhuma nova memória foi extraída nesta execução",
+        runSummaryTitle: "[Melu] resumo da execução ({runId})",
+        runSummaryProcessed: "[Melu] processadas: {count}",
+        runSummaryEffectiveNewMemories: "[Melu] novas memórias úteis: {count}",
+        runSummaryFailed: "[Melu] falhas: {count}",
+        runSummaryRemainingQueue: "[Melu] fila restante: {count}",
+        languagePromptTitle: "Selecione o idioma de exibição do Melu:",
+        menuHint: "Use as setas para navegar e Enter para confirmar.",
+        languagePromptInput: "Selecione um idioma:",
+        languagePromptRetry: "Selecione uma opção válida.",
+        languageSet: "Idioma de exibição: {language}",
+        mirrorPromptTitle: "Selecione a fonte do modelo GGUF de embedding:",
+        mirrorPromptInput: "Selecione a fonte do modelo:",
+        mirrorPromptRetry: "Selecione uma opção válida.",
+        mirrorHintHuggingFace: "Recomendado para redes globais",
+        mirrorHintModelScope: "Recomendado para redes da China continental",
+        mirrorSelectionRequired: "Você precisa escolher uma fonte espelho antes de configurar o modelo. Execute `melu init --mirror huggingface` ou `melu init --mirror modelscope`.",
+        embeddingDownload: "[Melu] Baixando modelo de embedding: {file}",
+        labelSource: "[Melu] Fonte: {label}",
+        labelSavedTo: "[Melu] Salvando em: {path}",
+        downloadProgressDownloadingTo: "Baixando para",
+        downloadProgressDownloadedTo: "Baixado para",
+        modelAlreadyAvailable: "[Melu] Modelo de embedding já encontrado: {path}",
+        modelSkipDownload: "[Melu] Ignorando download.",
+        runtimeBinaryUnavailable: "Não há um runtime pré-compilado do llama.cpp disponível para esta plataforma. O Melu não compila automaticamente dependências nativas locais. Use Node 20+ no macOS, Linux ou Windows arm64/x64.",
+        memoryUpdated: "[Melu] Memória atualizada: '{summary}' substituiu '{previous}'",
+        memoryNew: "[Melu] Nova memória: [{category}] {summary}",
+        embeddingFailed: "[Melu] Falha no embedding:",
+        claudePExtracting: "[Melu:DEBUG] Extraindo memória via claude -p",
+        claudePExitCode: "[Melu] claude -p terminou com código {code}, stderr: {stderr}",
+        claudePStartFailed: "[Melu] Falha ao iniciar claude -p: {message}",
+    },
+};
+export function resolveUiLanguage(language) {
+    return language ?? "en";
+}
+export function getUiLanguageLabel(language) {
+    return SUPPORTED_UI_LANGUAGES.find((item) => item.value === language)?.label ?? "English";
+}
+export function t(language, key, params = {}) {
+    const resolved = resolveUiLanguage(language);
+    let template = MESSAGES[resolved][key] ?? MESSAGES.en[key];
+    for (const [name, value] of Object.entries(params)) {
+        template = template.replaceAll(`{${name}}`, String(value));
+    }
+    return template;
+}
+export function createI18n(language) {
+    const resolved = resolveUiLanguage(language);
+    return {
+        language: resolved,
+        t(key, params = {}) {
+            return t(resolved, key, params);
+        },
+    };
+}
+export function getLocalizedMirrorLabel(mirror, _language) {
+    if (mirror === "huggingface") {
+        return "Hugging Face (Global)";
+    }
+    return "ModelScope (CN)";
+}
+//# sourceMappingURL=i18n.js.map