@dotcontext/mcp 0.9.0

package/dist/utils/i18n.d.ts

@@ -0,0 +1,530 @@
+export type Locale = 'en' | 'pt-BR';
+export declare const SUPPORTED_LOCALES: Locale[];
+export declare const DEFAULT_LOCALE: Locale;
+declare const englishMessages: {
+    readonly 'cli.description': "Sync .context assets, reverse-sync tool state, and install MCP integrations for your repository";
+    readonly 'global.options.lang': "Language for CLI output (en or pt-BR)";
+    readonly 'ui.version': "Version {version}";
+    readonly 'ui.projectConfiguration.title': "Project Configuration";
+    readonly 'ui.projectConfiguration.repository': "Repository";
+    readonly 'ui.projectConfiguration.output': "Output";
+    readonly 'ui.projectConfiguration.mode': "Mode";
+    readonly 'ui.progress.starting': "Starting...";
+    readonly 'ui.analysis.complete.title': "Analysis Complete";
+    readonly 'ui.analysis.files': "Files";
+    readonly 'ui.analysis.directories': "Directories";
+    readonly 'ui.analysis.totalSize': "Total Size";
+    readonly 'ui.fileTypeDistribution.title': "File Type Distribution";
+    readonly 'ui.generationSummary.title': "Scaffold Complete";
+    readonly 'ui.generationSummary.documentation': "Documentation";
+    readonly 'ui.generationSummary.agents': "Agents";
+    readonly 'ui.generationSummary.skills': "Skills";
+    readonly 'ui.generationSummary.timeElapsed': "Time";
+    readonly 'ui.generationSummary.nextStep': "Next step: customize the generated templates to match your project.";
+    readonly 'ui.error.title': "Error";
+    readonly 'ui.splash.directoryLabel': "directory";
+    readonly 'info.prompt.title': "System Prompt";
+    readonly 'info.prompt.usingCustom': "Using prompt from {path}.";
+    readonly 'info.prompt.usingPackage': "Using packaged prompt at {path}.";
+    readonly 'info.prompt.usingBundled': "Using built-in prompt bundled with dotcontext.";
+    readonly 'info.update.available.title': "Update available";
+    readonly 'info.update.available.detail': "A newer version {latest} is available (current {current}). Update with {command}.";
+    readonly 'commands.init.description': "Generate docs and agent scaffolding for a repository";
+    readonly 'commands.init.arguments.repoPath': "Path to the repository to analyze";
+    readonly 'commands.init.arguments.type': "Scaffold type: \"docs\", \"agents\", or \"both\" (default)";
+    readonly 'commands.init.options.output': "Output directory for generated assets";
+    readonly 'commands.init.options.exclude': "Glob patterns to exclude from analysis";
+    readonly 'commands.init.options.include': "Glob patterns to include during analysis";
+    readonly 'commands.init.options.verbose': "Enable verbose logging";
+    readonly 'commands.init.options.noSemantic': "Disable semantic code analysis (enabled by default)";
+    readonly 'commands.init.options.noContentStubs': "Disable content stubs (section headings and guidance) in scaffolds";
+    readonly 'commands.fill.description': "Use an LLM to fill generated docs and agent playbooks with the latest repo context";
+    readonly 'commands.fill.arguments.repoPath': "Path to the repository root used to build context";
+    readonly 'commands.fill.options.output': "Scaffold directory containing docs/ and agents/";
+    readonly 'commands.fill.options.apiKey': "API key for the LLM provider";
+    readonly 'commands.fill.options.model': "LLM model to use";
+    readonly 'commands.fill.options.provider': "LLM provider (openrouter, openai, anthropic, google)";
+    readonly 'commands.fill.options.baseUrl': "Custom base URL for provider APIs";
+    readonly 'commands.fill.options.prompt': "Path to an instruction prompt";
+    readonly 'commands.fill.options.limit': "Maximum number of files to process";
+    readonly 'commands.fill.options.exclude': "Glob patterns to exclude from repository analysis";
+    readonly 'commands.fill.options.include': "Glob patterns to include during analysis";
+    readonly 'commands.fill.options.verbose': "Enable verbose logging";
+    readonly 'commands.fill.options.noSemantic': "Disable semantic context mode and use tool-based exploration instead";
+    readonly 'commands.fill.options.languages': "Programming languages to analyze (e.g., typescript,python)";
+    readonly 'commands.fill.options.useLsp': "Enable LSP for deeper semantic analysis (type info, references)";
+    readonly 'prompts.fill.semantic': "Use semantic context mode? (faster, fewer tokens - recommended)";
+    readonly 'prompts.fill.languages': "Select programming languages for analysis";
+    readonly 'prompts.fill.useLsp': "Use LSP for deeper type analysis? (slower but more accurate)";
+    readonly 'commands.plan.description': "Create a development plan that links documentation and agent playbooks";
+    readonly 'commands.plan.arguments.planName': "Name of the plan (used to create the file slug)";
+    readonly 'commands.plan.options.output': "Output directory for generated plan files";
+    readonly 'commands.plan.options.title': "Custom title for the plan document";
+    readonly 'commands.plan.options.summary': "Seed summary for the plan header";
+    readonly 'commands.plan.options.force': "Overwrite the plan if it already exists (scaffold mode)";
+    readonly 'commands.plan.options.fill': "Use an LLM to fill or update the plan instead of scaffolding";
+    readonly 'commands.plan.options.repo': "Repository root for semantic context";
+    readonly 'commands.plan.options.apiKey': "API key for the LLM provider";
+    readonly 'commands.plan.options.model': "LLM model to use";
+    readonly 'commands.plan.options.provider': "LLM provider (openrouter, openai, anthropic, google)";
+    readonly 'commands.plan.options.baseUrl': "Custom base URL for provider APIs";
+    readonly 'commands.plan.options.prompt': "Path to a plan update instruction prompt";
+    readonly 'commands.plan.options.dryRun': "Preview updates without writing files";
+    readonly 'commands.plan.options.include': "Glob patterns to include during repository analysis";
+    readonly 'commands.plan.options.exclude': "Glob patterns to exclude from repository analysis";
+    readonly 'commands.plan.options.verbose': "Enable verbose logging";
+    readonly 'commands.plan.options.noSemantic': "Disable semantic code analysis (enabled by default)";
+    readonly 'commands.plan.options.noLsp': "Disable LSP semantic analysis (enabled by default for plans)";
+    readonly 'errors.init.scaffoldFailed': "Failed to scaffold repository assets";
+    readonly 'errors.fill.failed': "Failed to fill documentation with LLM assistance";
+    readonly 'errors.plan.creationFailed': "Failed to create plan template";
+    readonly 'errors.init.invalidType': "Invalid scaffold type \"{value}\". Expected one of: {allowed}";
+    readonly 'errors.common.repoMissing': "Repository path does not exist: {path}";
+    readonly 'warnings.scaffold.noneSelected': "No documentation or agent playbooks selected. Nothing to scaffold.";
+    readonly 'warnings.agents.missingDirectory': "No agents directory found. Initialize or import context through MCP first.";
+    readonly 'steps.init.analyze': "Analyzing repository structure";
+    readonly 'steps.init.docs': "Scaffolding documentation";
+    readonly 'steps.init.agents': "Scaffolding agent playbooks";
+    readonly 'spinner.repo.scanning': "Scanning repository...";
+    readonly 'spinner.repo.scanComplete': "Found {fileCount} files across {directoryCount} directories";
+    readonly 'spinner.docs.creating': "Creating docs directory and templates...";
+    readonly 'spinner.docs.creatingWithSemantic': "Analyzing codebase and creating docs templates...";
+    readonly 'spinner.docs.created': "Documentation scaffold created ({count} files)";
+    readonly 'spinner.agents.creating': "Creating agent directory and templates...";
+    readonly 'spinner.agents.creatingWithSemantic': "Analyzing codebase and creating agent playbooks...";
+    readonly 'spinner.agents.created': "Agent scaffold created ({count} files)";
+    readonly 'spinner.plan.creating': "Creating plan template...";
+    readonly 'spinner.plan.created': "Plan template created";
+    readonly 'spinner.plan.creationFailed': "Failed to create plan template";
+    readonly 'success.scaffold.ready': "Scaffold ready in {path}";
+    readonly 'success.plan.createdAt': "Plan created at {path}";
+    readonly 'errors.fill.missingDocsScaffold': "Documentation scaffold not found. Run `dotcontext init` first.";
+    readonly 'errors.fill.missingAgentsScaffold': "Agent scaffold not found. Run `dotcontext init` first.";
+    readonly 'errors.fill.missingScaffold': "No scaffold found. Run `dotcontext init` first to create docs and/or agents.";
+    readonly 'steps.fill.analyze': "Analyzing repository structure";
+    readonly 'warnings.fill.noTargets': "No Markdown files found in .context/docs or .context/agents. Run \"dotcontext init\" before filling.";
+    readonly 'steps.fill.processFiles': "Updating {count} files with {model}";
+    readonly 'spinner.fill.processing': "Processing {path}...";
+    readonly 'spinner.fill.noContent': "No content received for {path}";
+    readonly 'messages.fill.emptyResponse': "Empty response from LLM";
+    readonly 'messages.fill.previewStart': "--- Preview Start ---";
+    readonly 'messages.fill.previewEnd': "--- Preview End ---";
+    readonly 'spinner.fill.updated': "Updated {path}";
+    readonly 'spinner.fill.failed': "Failed {path}";
+    readonly 'steps.fill.summary': "Summarizing LLM usage";
+    readonly 'success.fill.completed': "LLM-assisted update complete. Review the changes and commit when ready.";
+    readonly 'errors.plan.invalidName': "Plan name must contain at least one alphanumeric character.";
+    readonly 'messages.plan.regenerated': "Regenerated {path} before LLM fill.";
+    readonly 'messages.plan.created': "Created {path} before LLM fill.";
+    readonly 'info.plan.scaffolded.title': "Plan scaffolded";
+    readonly 'errors.plan.missingPlansDir': "Plans directory not found. Run `dotcontext plan <name>` to create one.";
+    readonly 'errors.plan.notFound': "Plan not found. Expected {expected}.";
+    readonly 'steps.plan.summary': "Summarizing repository state";
+    readonly 'spinner.planFill.analyzingRepo': "Analyzing repository...";
+    readonly 'spinner.planFill.summaryReady': "Repository summary ready";
+    readonly 'steps.plan.update': "Updating {path} with {model}";
+    readonly 'spinner.planFill.updating': "Filling {path}...";
+    readonly 'spinner.planFill.noContent': "No content received from LLM";
+    readonly 'spinner.planFill.dryRun': "Dry run - preview follows";
+    readonly 'spinner.planFill.updated': "Updated {path}";
+    readonly 'spinner.planFill.failed': "Failed to fill plan";
+    readonly 'steps.plan.summaryResults': "Summarizing LLM usage";
+    readonly 'success.plan.filled': "Plan fill complete. Review the updates and commit when ready.";
+    readonly 'errors.commands.analyzeRemoved': "The analyze command has been removed in the scaffolding-only version of dotcontext.";
+    readonly 'errors.commands.fillRemoved': "The fill command is now available only through MCP-enabled AI tools.";
+    readonly 'errors.commands.updateRemoved': "The update command is no longer supported. Re-run `dotcontext init` to refresh scaffolds.";
+    readonly 'errors.commands.previewRemoved': "Preview mode has been retired. Use the generated docs and agent templates directly.";
+    readonly 'errors.commands.guidelinesRemoved': "Guidelines generation relied on LLMs and is no longer available.";
+    readonly 'errors.cli.executionFailed': "CLI execution failed";
+    readonly 'errors.init.overwriteDeclined': "Scaffold aborted to avoid overwriting existing content.";
+    readonly 'prompts.main.action': "What would you like to do?";
+    readonly 'prompts.main.choice.scaffold': "Generate documentation/agent scaffolding";
+    readonly 'prompts.main.choice.fill': "Fill docs and agents with an LLM";
+    readonly 'prompts.main.choice.plan': "Create a development plan";
+    readonly 'prompts.main.choice.changeLanguage': "Change language";
+    readonly 'prompts.main.choice.exit': "Exit interactive mode";
+    readonly 'prompts.scaffold.repoPath': "Repository path to analyze";
+    readonly 'prompts.scaffold.type': "What should we scaffold?";
+    readonly 'prompts.scaffold.typeBoth': "Docs and agents";
+    readonly 'prompts.scaffold.typeDocs': "Docs only";
+    readonly 'prompts.scaffold.typeAgents': "Agents only";
+    readonly 'prompts.scaffold.selectComponents': "What should we scaffold? (Select all that apply)";
+    readonly 'prompts.scaffold.componentDocs': "Documentation";
+    readonly 'prompts.scaffold.componentAgents': "Agent playbooks";
+    readonly 'prompts.scaffold.componentSkills': "Skills";
+    readonly 'spinner.skills.creating': "Creating skills directory and templates...";
+    readonly 'spinner.skills.created': "Skills scaffold created ({count} files)";
+    readonly 'steps.init.skills': "Scaffolding skills";
+    readonly 'prompts.init.confirmOverwriteDocs': "Documentation already exists at {path}. Overwrite existing files?";
+    readonly 'prompts.init.confirmOverwriteAgents': "Agent playbooks already exist at {path}. Overwrite existing files?";
+    readonly 'prompts.init.confirmOverwriteSkills': "Skills already exist at {path}. Overwrite existing files?";
+    readonly 'prompts.common.verbose': "Enable verbose logging?";
+    readonly 'prompts.fill.repoPath': "Repository path containing the scaffold";
+    readonly 'prompts.fill.promptPath': "Custom prompt path (leave blank to use the bundled default)";
+    readonly 'prompts.fill.limit': "Maximum number of files to update (leave blank for all)";
+    readonly 'prompts.fill.overrideModel': "Override provider/model configuration?";
+    readonly 'prompts.fill.provider': "Select LLM provider";
+    readonly 'prompts.fill.provider.openrouter': "OpenRouter (access to multiple models)";
+    readonly 'prompts.fill.provider.openai': "OpenAI (GPT-4, etc.)";
+    readonly 'prompts.fill.provider.anthropic': "Anthropic (Claude)";
+    readonly 'prompts.fill.provider.google': "Google (Gemini)";
+    readonly 'prompts.fill.model': "Model identifier";
+    readonly 'prompts.fill.provideApiKey': "Provide an API key for this run?";
+    readonly 'prompts.fill.apiKey': "API key";
+    readonly 'prompts.plan.name': "Plan name (used for the file slug)";
+    readonly 'prompts.plan.goal': "What should be planned?";
+    readonly 'prompts.plan.mode': "How would you like to work with this plan?";
+    readonly 'prompts.plan.modeScaffold': "Scaffold a plan template";
+    readonly 'prompts.plan.modeFill': "Create a plan with AI (outline or AI-filled)";
+    readonly 'prompts.plan.summary': "Optional summary to seed the plan (leave blank to add later)";
+    readonly 'prompts.plan.repoPath': "Repository root for context";
+    readonly 'prompts.plan.dryRun': "Preview updates without writing files?";
+    readonly 'prompts.plan.useLsp': "Use LSP for deeper type analysis? (recommended for plans)";
+    readonly 'prompts.language.select': "Choose the CLI language / Escolha o idioma do CLI";
+    readonly 'prompts.language.option.en': "English / Inglês";
+    readonly 'prompts.language.option.pt-BR': "Portuguese (Brazil) / Português (Brasil)";
+    readonly 'errors.plan.fillFailed': "Failed to fill plan with LLM assistance";
+    readonly 'errors.fill.promptMissing': "Prompt file not found at {path}.";
+    readonly 'errors.fill.apiKeyMissing': "{provider} API key is required. Set one of {envVars} or use --api-key.";
+    readonly 'info.interactive.returning.title': "Main menu";
+    readonly 'info.interactive.returning.detail': "Returning to the interactive menu. Pick another action or choose Exit.";
+    readonly 'success.interactive.goodbye': "Goodbye! Thanks for using dotcontext.";
+    readonly 'agent.starting': "Starting";
+    readonly 'agent.complete': "Complete";
+    readonly 'agent.steps': "steps";
+    readonly 'agent.type.documentation': "Documentation Agent";
+    readonly 'agent.type.playbook': "Playbook Agent";
+    readonly 'agent.type.plan': "Plan Agent";
+    readonly 'agent.type.fill': "Fill Agent";
+    readonly 'agent.type.skill': "Skill Agent";
+    readonly 'commands.sync.description': "Sync agent playbooks to AI tool directories (.claude, .github, etc.)";
+    readonly 'commands.sync.options.source': "Source agents directory";
+    readonly 'commands.sync.options.target': "Target directories to sync to";
+    readonly 'commands.sync.options.mode': "Reference type: symlink or markdown";
+    readonly 'commands.sync.options.preset': "Built-in preset: claude, github, cursor, or all";
+    readonly 'commands.sync.options.force': "Overwrite existing files/symlinks";
+    readonly 'commands.sync.options.dryRun': "Preview changes without writing";
+    readonly 'commands.sync.options.verbose': "Enable verbose logging";
+    readonly 'prompts.main.choice.syncAgents': "Sync agents to AI tools";
+    readonly 'prompts.main.choice.create': "Create documentation for this project";
+    readonly 'prompts.main.choice.moreOptions': "More options...";
+    readonly 'prompts.main.choice.viewPending': "View pending files";
+    readonly 'prompts.main.choice.updateDocs': "Update documentation";
+    readonly 'prompts.main.choice.updateDocsBehind': "Update documentation ({daysBehind} days behind)";
+    readonly 'prompts.main.choice.rescaffold': "Re-scaffold (overwrite)";
+    readonly 'prompts.main.unfilledPrompt': "{count} files still need content. What would you like to do?";
+    readonly 'prompts.main.pendingFilesHeader': "Files pending content:";
+    readonly 'prompts.setup.confirmContinue': "This will create and fill documentation. Continue?";
+    readonly 'spinner.setup.creatingStructure': "Creating documentation structure...";
+    readonly 'spinner.setup.fillingDocs': "Filling documentation with AI...";
+    readonly 'info.setup.incomplete.title': "Setup incomplete";
+    readonly 'info.setup.incomplete.detail': "Use MCP in your AI tool to fill or refresh documentation later.";
+    readonly 'info.setup.enhanceWithAI': "Use MCP in your AI tool to fill or refresh context files.";
+    readonly 'success.setup.docsCreated': "Documentation created!";
+    readonly 'success.setup.scaffoldCreated': "Scaffolds created with codebase context!";
+    readonly 'info.setup.reviewFiles': "Review the files in .context/ and commit them.";
+    readonly 'prompts.sync.source': "Source agents directory";
+    readonly 'prompts.sync.mode': "How should references be created?";
+    readonly 'prompts.sync.modeSymlink': "Symlinks (recommended)";
+    readonly 'prompts.sync.modeMarkdown': "Markdown reference files";
+    readonly 'prompts.sync.targetType': "Where to sync agents?";
+    readonly 'prompts.sync.targetPreset': "Use a preset (Claude, GitHub, etc.)";
+    readonly 'prompts.sync.targetCustom': "Custom path";
+    readonly 'prompts.sync.selectPreset': "Select target preset";
+    readonly 'prompts.sync.preset.claude': "Claude Code (.claude/agents)";
+    readonly 'prompts.sync.preset.github': "GitHub Copilot (.github/agents)";
+    readonly 'prompts.sync.preset.cursor': "Cursor (.cursor/agents)";
+    readonly 'prompts.sync.preset.all': "All presets";
+    readonly 'prompts.sync.customPath': "Enter custom target path";
+    readonly 'prompts.sync.dryRun': "Preview changes first (dry-run)?";
+    readonly 'prompts.sync.force': "Overwrite existing files?";
+    readonly 'errors.sync.failed': "Failed to sync agents";
+    readonly 'errors.sync.noTargetsSpecified': "No targets specified. Use --target or --preset.";
+    readonly 'errors.sync.sourceMissing': "Source directory does not exist: {path}";
+    readonly 'errors.sync.sourceNotDirectory': "Source path is not a directory: {path}";
+    readonly 'warnings.sync.noAgentsFound': "No agent files found in source directory.";
+    readonly 'spinner.sync.processing': "Syncing to {path}...";
+    readonly 'spinner.sync.complete': "Synced {count} files to {path}";
+    readonly 'spinner.sync.failed': "Failed to sync to {path}";
+    readonly 'success.sync.completed': "Agent sync complete. Your AI tools are now configured.";
+    readonly 'steps.sync.processingTarget': "Processing target: {path}";
+    readonly 'steps.sync.summary': "Generating sync summary";
+    readonly 'info.sync.foundAgents': "Agent files discovered";
+    readonly 'info.sync.foundAgentsDetail': "Found {count} agent playbooks to sync";
+    readonly 'commands.importRules.description': "Import cursor rules and AI assistant rules to .context/docs";
+    readonly 'commands.importRules.options.source': "Source paths to scan for rules";
+    readonly 'commands.importRules.options.target': "Target directory for imported rules";
+    readonly 'commands.importRules.options.format': "Output format: markdown, formatted, or raw";
+    readonly 'commands.importRules.options.force': "Overwrite existing files";
+    readonly 'commands.importRules.options.dryRun': "Preview changes without writing";
+    readonly 'commands.importRules.options.verbose': "Enable verbose logging";
+    readonly 'commands.importRules.options.autoDetect': "Auto-detect rules in common locations";
+    readonly 'commands.importAgents.description': "Import agents from AI tool directories to .context/agents";
+    readonly 'commands.importAgents.options.source': "Source paths to scan for agents";
+    readonly 'commands.importAgents.options.target': "Target directory for imported agents";
+    readonly 'commands.importAgents.options.force': "Overwrite existing files";
+    readonly 'commands.importAgents.options.dryRun': "Preview changes without writing";
+    readonly 'commands.importAgents.options.verbose': "Enable verbose logging";
+    readonly 'commands.importAgents.options.autoDetect': "Auto-detect agents in common locations";
+    readonly 'warnings.import.noRulesFound': "No rules files found.";
+    readonly 'warnings.import.noAgentsFound': "No agent files found.";
+    readonly 'spinner.import.detectingRules': "Detecting rules files...";
+    readonly 'spinner.import.detectingAgents': "Detecting agent files...";
+    readonly 'spinner.import.scanningPaths': "Scanning source paths...";
+    readonly 'spinner.import.importing': "Importing to {path}...";
+    readonly 'spinner.import.complete': "Imported {count} files to {path}";
+    readonly 'info.import.foundRules': "Rules files discovered";
+    readonly 'info.import.foundRulesDetail': "Found {count} rules files to import";
+    readonly 'info.import.foundAgents': "Agent files discovered";
+    readonly 'info.import.foundAgentsDetail': "Found {count} agent files to import";
+    readonly 'success.import.completed': "Import completed successfully.";
+    readonly 'errors.import.failed': "Failed to import files";
+    readonly 'prompts.mode.select': "How would you like to configure this operation?";
+    readonly 'prompts.mode.quick': "Quick Start (use smart defaults)";
+    readonly 'prompts.mode.advanced': "Advanced (customize all options)";
+    readonly 'prompts.summary.title': "Configuration Summary";
+    readonly 'prompts.summary.proceed': "Proceed with this configuration?";
+    readonly 'prompts.llm.autoDetected': "Auto-detected from environment";
+    readonly 'prompts.quick.confirmRepo': "Use this repository?";
+    readonly 'prompts.sync.quickTarget': "Where should agents be synced?";
+    readonly 'prompts.sync.quickTarget.common': "Claude Code + GitHub Copilot (recommended)";
+    readonly 'prompts.sync.quickTarget.claude': "Claude Code only";
+    readonly 'prompts.sync.quickTarget.all': "All AI tools";
+    readonly 'prompts.sync.quickTarget.custom': "Custom path...";
+    readonly 'prompts.main.choice.workflow': "PREVC Workflow";
+    readonly 'prompts.workflow.noWorkflowFound': "No PREVC workflow found. Create a new one?";
+    readonly 'prompts.workflow.projectName': "Project/feature name:";
+    readonly 'prompts.workflow.projectNameRequired': "Name is required";
+    readonly 'prompts.workflow.description': "Brief description (for scale detection):";
+    readonly 'prompts.workflow.scale': "Project scale:";
+    readonly 'prompts.workflow.scale.auto': "Auto-detect (based on description)";
+    readonly 'prompts.workflow.scale.quick': "Quick - Bug fixes, tweaks (~5 min)";
+    readonly 'prompts.workflow.scale.small': "Small - Simple features (~15 min)";
+    readonly 'prompts.workflow.scale.medium': "Medium - Regular features (~30 min)";
+    readonly 'prompts.workflow.scale.large': "Large - Complex systems, compliance (~1+ hours)";
+    readonly 'prompts.workflow.action': "Workflow action:";
+    readonly 'prompts.workflow.action.advance': "Advance to next phase";
+    readonly 'prompts.workflow.action.refresh': "Refresh status";
+    readonly 'prompts.workflow.action.back': "Back to main menu";
+    readonly 'success.workflow.initialized': "Workflow PREVC initialized: {name}";
+    readonly 'success.workflow.advanced': "Advanced to phase: {phase} - {phaseName}";
+    readonly 'success.workflow.completed': "Workflow completed.";
+    readonly 'errors.workflow.initFailed': "Failed to initialize workflow";
+    readonly 'errors.workflow.advanceFailed': "Failed to advance workflow";
+    readonly 'errors.workflow.notFound': "No workflow found. Run \"workflow init <name>\" first.";
+    readonly 'info.workflow.scale': "Scale";
+    readonly 'info.workflow.currentPhase': "Current Phase";
+    readonly 'prompts.workflow.workflowComplete': "Current workflow is complete. What would you like to do?";
+    readonly 'prompts.workflow.action.newWorkflow': "Start a new workflow";
+    readonly 'prompts.workflow.action.viewStatus': "View completed workflow status";
+    readonly 'prompts.workflow.confirmNewWorkflow': "This will replace the current workflow. Continue?";
+    readonly 'commands.start.description': "Smart start: initialize context and start workflow in one command";
+    readonly 'commands.start.arguments.featureName': "Optional feature name to start a workflow";
+    readonly 'commands.start.options.template': "Workflow template: hotfix, feature, mvp, or auto";
+    readonly 'commands.start.options.skipFill': "Skip AI-assisted documentation filling";
+    readonly 'commands.start.options.skipWorkflow': "Skip workflow initialization";
+    readonly 'commands.previewSplash.description': "Render the interactive splash screen preview";
+    readonly 'commands.previewSplash.options.title': "Override the splash title";
+    readonly 'commands.previewSplash.options.directory': "Directory to display in the splash";
+    readonly 'spinner.start.detectingStack': "Detecting technology stack...";
+    readonly 'spinner.start.stackDetected': "Stack detected: {stack}";
+    readonly 'spinner.start.initializing': "Initializing project context...";
+    readonly 'spinner.start.initialized': "Project context initialized";
+    readonly 'spinner.start.initFailed': "Failed to initialize context";
+    readonly 'spinner.start.filling': "Filling documentation with AI...";
+    readonly 'spinner.start.filled': "Documentation filled";
+    readonly 'spinner.start.fillFailed': "Documentation refresh is now handled through MCP-enabled AI tools";
+    readonly 'errors.start.workflowFailed': "Failed to start workflow";
+    readonly 'success.start.complete': "Project ready! {details}";
+    readonly 'commands.mcpInstall.description': "Install MCP server configuration for AI tools (Claude Code, Cursor, etc.)";
+    readonly 'commands.mcpInstall.options.global': "Install globally in home directory (default)";
+    readonly 'commands.mcpInstall.options.local': "Install locally in project directory";
+    readonly 'commands.mcpInstall.options.dryRun': "Preview changes without writing";
+    readonly 'commands.mcpInstall.options.verbose': "Enable verbose output";
+    readonly 'commands.mcpInstall.selectTool': "Select the tool to configure MCP for:";
+    readonly 'commands.mcpInstall.allDetected': "All detected tools";
+    readonly 'labels.detected': "detected";
+    readonly 'info.mcp.wouldInstall': "Would install MCP for {tool} at {path}";
+    readonly 'info.mcp.installed': "MCP configured for {tool} at {path}";
+    readonly 'info.mcp.alreadyConfigured': "{tool} already has MCP configured";
+    readonly 'info.mcp.restartTools': "Restart your AI tools to apply the MCP configuration.";
+    readonly 'success.mcp.installed': "MCP installed for {count} tool(s)";
+    readonly 'warnings.mcp.noToolsDetected': "No supported AI tools detected. Specify a tool manually.";
+    readonly 'errors.mcp.unsupportedTool': "Unsupported tool: {tool}. Supported: {supported}";
+    readonly 'errors.mcp.installFailed': "Failed to install MCP for {tool}";
+    readonly 'commands.mcpInstall.selectTool.claudeDesktop': "Claude Desktop";
+    readonly 'commands.mcpInstall.selectTool.vscode': "VS Code (GitHub Copilot)";
+    readonly 'commands.mcpInstall.selectTool.roo': "Roo Code";
+    readonly 'commands.mcpInstall.selectTool.warp': "Warp Terminal";
+    readonly 'commands.mcpInstall.selectTool.amazonq': "Amazon Q Developer CLI";
+    readonly 'commands.mcpInstall.selectTool.geminiCli': "Gemini CLI";
+    readonly 'commands.mcpInstall.selectTool.kiro': "Kiro";
+    readonly 'commands.mcpInstall.selectTool.zed': "Zed Editor";
+    readonly 'commands.mcpInstall.selectTool.jetbrains': "JetBrains IDEs";
+    readonly 'commands.export.description': "Export rules from .context to AI tool directories";
+    readonly 'commands.export.options.source': "Source directory for rules";
+    readonly 'commands.export.options.targets': "Target paths to export to";
+    readonly 'commands.export.options.preset': "Export preset: cursor, claude, github, windsurf, cline, aider, codex, or all";
+    readonly 'commands.export.options.force': "Overwrite existing files";
+    readonly 'commands.export.options.dryRun': "Preview changes without writing";
+    readonly 'spinner.export.exporting': "Exporting to {target}...";
+    readonly 'spinner.export.exported': "Exported to {target}";
+    readonly 'spinner.export.skipped': "Skipped {target} (already exists)";
+    readonly 'spinner.export.failed': "Failed to export to {target}";
+    readonly 'spinner.export.dryRun': "Would export to {target}";
+    readonly 'errors.export.noTargets': "No export targets specified. Use --preset or --targets.";
+    readonly 'errors.export.noRules': "No rules found in source directory.";
+    readonly 'success.export.completed': "Exported rules to {count} target(s)";
+    readonly 'commands.report.description': "Generate workflow progress report";
+    readonly 'commands.report.options.format': "Output format: console, markdown, or json";
+    readonly 'commands.report.options.output': "Output file path (for markdown/json)";
+    readonly 'commands.report.options.includeStack': "Include technology stack analysis";
+    readonly 'errors.report.noWorkflow': "No workflow found. Run \"workflow init\" first.";
+    readonly 'success.report.saved': "Report saved to {path}";
+    readonly 'dashboard.title': "Workflow Dashboard";
+    readonly 'dashboard.phase.completed': "Completed";
+    readonly 'dashboard.phase.inProgress': "In Progress";
+    readonly 'dashboard.phase.pending': "Pending";
+    readonly 'dashboard.phase.skipped': "Skipped";
+    readonly 'autoAdvance.detected': "Detected {count} output(s) for phase {phase}";
+    readonly 'autoAdvance.suggest': "Ready to advance to next phase?";
+    readonly 'prompts.workflow.template': "Select workflow template:";
+    readonly 'prompts.workflow.template.hotfix': "Hotfix - Quick bug fix (E → V)";
+    readonly 'prompts.workflow.template.feature': "Feature - Regular development (P → R → E → V)";
+    readonly 'prompts.workflow.template.mvp': "MVP - Full product workflow (P → R → E → V → C)";
+    readonly 'prompts.workflow.template.auto': "Auto-detect based on description";
+    readonly 'commands.skill.description': "Manage skills (on-demand expertise for AI agents)";
+    readonly 'commands.skill.init.description': "Initialize skills directory with built-in skills";
+    readonly 'commands.skill.fill.description': "Fill skills with AI-generated project-specific content";
+    readonly 'commands.skill.list.description': "List available skills";
+    readonly 'commands.skill.export.description': "Export skills to AI tool directories (Claude, Gemini, Codex)";
+    readonly 'commands.skill.create.description': "Create a new custom skill";
+    readonly 'prompts.main.choice.skills': "Manage skills";
+    readonly 'prompts.skill.action': "What would you like to do with skills?";
+    readonly 'prompts.skill.action.init': "Initialize built-in skills";
+    readonly 'prompts.skill.action.fill': "Fill skills with AI";
+    readonly 'prompts.skill.action.list': "List available skills";
+    readonly 'prompts.skill.action.export': "Export skills to AI tools";
+    readonly 'prompts.skill.action.create': "Create a custom skill";
+    readonly 'prompts.skill.action.back': "Back to main menu";
+    readonly 'prompts.skill.name': "Skill name:";
+    readonly 'prompts.skill.description': "Skill description:";
+    readonly 'prompts.skill.phases': "PREVC phases (comma-separated: P,R,E,V,C):";
+    readonly 'prompts.skill.exportPreset': "Export to which AI tools?";
+    readonly 'prompts.skill.exportPreset.all': "All tools (Claude, Gemini, Codex)";
+    readonly 'prompts.skill.exportPreset.claude': "Claude Code only";
+    readonly 'prompts.skill.exportPreset.gemini': "Gemini CLI only";
+    readonly 'prompts.skill.exportPreset.codex': "Codex CLI only";
+    readonly 'success.skill.initialized': "Skills initialized in {path}";
+    readonly 'success.skill.created': "Created skill: {name}";
+    readonly 'success.skill.exported': "Exported {count} skills to {targets} targets";
+    readonly 'success.skill.filled': "Filled {count} skills with project-specific content";
+    readonly 'errors.skill.initFailed': "Failed to initialize skills";
+    readonly 'errors.skill.listFailed': "Failed to list skills";
+    readonly 'errors.skill.exportFailed': "Failed to export skills";
+    readonly 'errors.skill.createFailed': "Failed to create skill";
+    readonly 'errors.skill.fillFailed': "Failed to fill skills";
+    readonly 'errors.skill.missingScaffold': "Skills directory not found. Run \"skill init\" first.";
+    readonly 'steps.skill.discover': "Discovering skills";
+    readonly 'steps.skill.loadContext': "Loading docs and agents context";
+    readonly 'steps.skill.fillSkills': "Filling {count} skills with {model}";
+    readonly 'steps.skill.summary': "Summary";
+    readonly 'spinner.skill.discovering': "Discovering scaffolded skills...";
+    readonly 'spinner.skill.discovered': "Found {count} skills to fill";
+    readonly 'spinner.skill.loadingContext': "Loading docs and agents context...";
+    readonly 'spinner.skill.contextLoaded': "Loaded docs ({docsSize} chars) and agents ({agentsSize} chars)";
+    readonly 'spinner.skill.noContent': "No content generated for {skill}";
+    readonly 'spinner.skill.filled': "Filled {skill}";
+    readonly 'spinner.skill.failed': "Failed to fill {skill}";
+    readonly 'warnings.skill.noTargets': "No skills found to fill. Run \"skill init\" first.";
+    readonly 'info.skill.generated': "Generated";
+    readonly 'info.skill.skipped': "Skipped (already exist)";
+    readonly 'info.skill.path': "Path";
+    readonly 'prompts.main.choice.quickSync': "Quick Sync";
+    readonly 'prompts.quickSync.selectComponents': "Select components to sync:";
+    readonly 'prompts.quickSync.components.agents': "Agents";
+    readonly 'prompts.quickSync.components.skills': "Skills";
+    readonly 'prompts.quickSync.components.docs': "Documentation";
+    readonly 'prompts.quickSync.noComponentsSelected': "No components selected";
+    readonly 'prompts.quickSync.selectAgentTargets': "Select agent sync targets:";
+    readonly 'prompts.quickSync.selectSkillTargets': "Select skill export targets:";
+    readonly 'prompts.quickSync.selectDocTargets': "Select doc export targets:";
+    readonly 'prompts.quickSync.syncing.agents': "Syncing agents...";
+    readonly 'prompts.quickSync.syncing.skills': "Exporting skills...";
+    readonly 'prompts.quickSync.syncing.rules': "Exporting rules...";
+    readonly 'prompts.quickSync.syncing.docs': "Checking docs...";
+    readonly 'prompts.quickSync.docsOutdated': "{days} days old";
+    readonly 'prompts.quickSync.updateDocs': "Update docs too?";
+    readonly 'success.quickSync.complete': "Sync complete";
+    readonly 'prompts.main.choice.reverseSync': "Reverse Sync (import from AI tools)";
+    readonly 'prompts.reverseSync.detecting': "Detecting AI tool configurations...";
+    readonly 'prompts.reverseSync.detected': "Detected AI Tools:";
+    readonly 'prompts.reverseSync.noFilesFound': "No AI tool configuration files found";
+    readonly 'prompts.reverseSync.noComponentsSelected': "No components selected for import";
+    readonly 'prompts.reverseSync.selectComponents': "Select components to import:";
+    readonly 'prompts.reverseSync.mergeStrategy': "How should conflicts be handled?";
+    readonly 'prompts.reverseSync.strategy.skip': "Skip existing files";
+    readonly 'prompts.reverseSync.strategy.overwrite': "Overwrite existing files";
+    readonly 'prompts.reverseSync.strategy.merge': "Merge content (append)";
+    readonly 'prompts.reverseSync.strategy.rename': "Rename new files";
+    readonly 'success.reverseSync.complete': "Imported {count} files";
+    readonly 'errors.reverseSync.failed': "Reverse sync failed";
+    readonly 'prompts.main.choice.manageSkills': "Manage Skills";
+    readonly 'prompts.main.choice.manageAgents': "Manage Agents";
+    readonly 'prompts.main.choice.settings': "Settings (language)";
+    readonly 'prompts.main.choice.mcpInstall': "Install/Configure MCP";
+    readonly 'prompts.main.choice.startWorkflow': "Start Workflow";
+    readonly 'prompts.main.choice.createPlan': "Create Plan";
+    readonly 'prompts.main.choice.quickSetup': "Quick Setup (creates context from codebase)";
+    readonly 'prompts.main.choice.enhanceWithAI': "Enhance context with AI";
+    readonly 'prompts.agents.action': "Agents:";
+    readonly 'prompts.agents.choice.sync': "Sync to targets";
+    readonly 'prompts.agents.choice.create': "Create custom agent";
+    readonly 'prompts.agents.choice.list': "List agents";
+    readonly 'prompts.agents.choice.back': "Back";
+    readonly 'prompts.agent.name': "Agent name:";
+    readonly 'prompts.agent.description': "Agent description:";
+    readonly 'prompts.agent.role': "Agent role/specialty:";
+    readonly 'success.agent.created': "Created agent: {name}";
+    readonly 'spinner.agent.creating': "Creating agent with AI...";
+    readonly 'spinner.agent.created': "Agent created";
+    readonly 'prompts.settings.action': "Settings:";
+    readonly 'prompts.settings.choice.language': "Change language";
+    readonly 'prompts.settings.choice.back': "Back";
+    readonly 'prompts.modeSelect.select': "How would you like to use @dotcontext/cli?";
+    readonly 'prompts.modeSelect.choice.mcp': "Set up MCP for my AI tool (recommended — no API key needed)";
+    readonly 'prompts.modeSelect.choice.cli': "Use the interactive CLI for workflow, sync, imports, and MCP setup";
+    readonly 'prompts.modeSelect.choice.exit': "Exit";
+    readonly 'prompts.more.action': "More options:";
+    readonly 'prompts.more.choice.back': "Back";
+    readonly 'prompts.quickSync.mode': "Sync all (agents, skills, docs) to common targets?";
+    readonly 'prompts.quickSync.mode.syncAll': "Yes, sync all";
+    readonly 'prompts.quickSync.mode.customize': "Customize targets...";
+    readonly 'prompts.quickSync.mode.cancel': "Cancel";
+    readonly 'status.compact': "✓ Context ready ({docs} docs, {agents} agents, {skills} skills)";
+    readonly 'status.outdated': "⚠ Context outdated ({days} days) - refresh via MCP";
+    readonly 'status.new': "No context found. Use MCP or reverse sync.";
+    readonly 'status.unfilled': "Context found, {count} files still need content";
+    readonly 'status.detected.project': "Detected: {languages} project";
+    readonly 'prompts.pressEnter': "Press Enter to continue...";
+    readonly 'prompts.env.loadEnv': "Load environment variables from .env file?";
+    readonly 'configSummary.config': "Config:";
+    readonly 'configSummary.options': "Options:";
+    readonly 'configSummary.repo': "repo";
+    readonly 'configSummary.provider': "provider";
+    readonly 'configSummary.yes': "Yes";
+    readonly 'configSummary.no': "No";
+    readonly 'warnings.apiKey.empty': "API key is empty. LLM calls will likely fail.";
+    readonly 'warnings.apiKey.formatMismatch': "API key does not start with expected prefix \"{prefix}\" for {provider}. It may still work if correct.";
+    readonly 'prompts.analysis.back': "Back (cancel analysis options)";
+    readonly 'prompts.llm.back': "Back (cancel LLM configuration)";
+};
+export type TranslationKey = keyof typeof englishMessages;
+export type TranslateParams = Record<string, string | number | undefined>;
+export type TranslateFn = (key: TranslationKey, params?: TranslateParams) => string;
+export declare function createTranslator(locale: Locale): TranslateFn;
+export declare function normalizeLocale(locale: string): Locale;
+export declare function detectLocale(argv: string[], envLocale?: string | null, systemLocaleCandidates?: Array<string | null | undefined>): Locale;
+export declare function isSupportedLocale(locale: string): boolean;
+export {};
+//# sourceMappingURL=i18n.d.ts.map

package/dist/utils/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/utils/i18n.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC;AAEpC,eAAO,MAAM,iBAAiB,EAAE,MAAM,EAAoB,CAAC;AAC3D,eAAO,MAAM,cAAc,EAAE,MAAa,CAAC;AAE3C,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+hBX,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC;AA0iB1D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;AAE1E,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC;AAEpF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAQ5D;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EACzB,sBAAsB,GAAE,KAAK,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAM,GAC5D,MAAM,CAeR;AA4BD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD"}