@i18n-agent/mcp-client 1.0.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 FatCouple OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,264 @@
+# 🌍 i18n-agent MCP Client
+
+Professional translation service client for Claude, Cursor, VS Code, and other AI IDEs using the Model Context Protocol (MCP).
+
+[![npm version](https://badge.fury.io/js/%40i18n-agent%2Fmcp-client.svg)](https://www.npmjs.com/package/@i18n-agent/mcp-client)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## ✨ Features
+
+- **🎯 Smart Translation**: Context-aware translations with cultural adaptation
+- **📁 File Translation**: Support for JSON, YAML, CSV, XML, Markdown, and more
+- **💰 Credit Tracking**: Real-time credit balance and word count estimates
+- **🌐 30+ Languages**: Multi-tier language support with quality ratings
+- **🔧 Easy Setup**: One-command installation for major AI IDEs
+
+## 🚀 Quick Installation
+
+Install via npx (recommended):
+
+```bash
+npx @i18n-agent/mcp-client install
+```
+
+Or install globally:
+
+```bash
+npm install -g @i18n-agent/mcp-client
+i18n-agent-install
+```
+
+## 🔑 Setup API Key
+
+1. **Get your API key** from [i18nagent.ai/dashboard](https://i18nagent.ai/dashboard)
+
+2. **Set environment variable**:
+   ```bash
+   export API_KEY=your-api-key-here
+   ```
+
+3. **Make it permanent** (add to ~/.bashrc or ~/.zshrc):
+   ```bash
+   echo 'export API_KEY=your-api-key-here' >> ~/.zshrc
+   ```
+
+4. **Restart your AI IDE** to load the new configuration
+
+## 🎮 Usage Examples
+
+### Text Translation
+```
+Translate "Hello, how are you?" to Spanish for a casual audience
+```
+
+### File Translation
+```
+Translate this JSON file to French, preserving the structure
+```
+
+### Credit Check
+```
+Check my translation credits
+```
+
+### Language Support
+```
+List supported languages with quality ratings
+```
+
+## 🛠 Supported AI IDEs
+
+| IDE | Status | Config Location |
+|-----|--------|----------------|
+| **Claude Desktop** | ✅ Auto-configured | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| **Cursor** | ✅ Auto-configured | `~/.cursor/mcp_settings.json` |
+| **VS Code** | ✅ Auto-configured | `~/.vscode/mcp_settings.json` |
+| **Other MCP IDEs** | 🔧 Manual setup | Varies |
+
+## 🌐 Language Support
+
+### Tier 1 - Production Ready (80-90% Quality)
+- **en**: English
+- **es**: Spanish  
+- **fr**: French
+- **de**: German
+- **it**: Italian
+- **pt**: Portuguese
+- **nl**: Dutch
+
+### Tier 2 - Production Viable (50-75% Quality)
+- **ru**: Russian
+- **zh-CN**: Chinese (Simplified)
+- **ja**: Japanese
+- **ko**: Korean
+- **ar**: Arabic
+- **he**: Hebrew
+- **hi**: Hindi
+- **pl**: Polish
+- **cs**: Czech
+
+### Tier 3 - Basic Support (20-50% Quality)
+- **zh-TW**: Chinese (Traditional)
+- **th**: Thai
+- **vi**: Vietnamese
+- **sv**: Swedish
+- **da**: Danish
+- **no**: Norwegian
+- **fi**: Finnish
+- **tr**: Turkish
+- **hu**: Hungarian
+
+## 📁 Supported File Formats
+
+| Format | Extension | Features |
+|--------|-----------|----------|
+| JSON | `.json` | Preserves structure, nested objects |
+| YAML | `.yaml`, `.yml` | Maintains formatting, comments |
+| CSV | `.csv` | Handles quoted fields, commas |
+| XML/HTML | `.xml`, `.html` | Extracts text content |
+| Markdown | `.md` | Preserves formatting, skips code |
+| Properties | `.properties` | Key-value pairs |
+| Plain Text | `.txt` | Direct translation |
+
+## 🔧 Manual Setup
+
+If auto-installation fails, you can manually configure your IDE:
+
+### Claude Desktop
+Edit `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "i18n-agent": {
+      "command": "node",
+      "args": ["/path/to/mcp-client.js"],
+      "env": {
+        "MCP_SERVER_URL": "https://mcp.i18nagent.ai",
+        "API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### Cursor / VS Code
+Create `.cursor/mcp_settings.json` or `.vscode/mcp_settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "i18n-agent": {
+      "command": "node", 
+      "args": ["/path/to/mcp-client.js"],
+      "env": {
+        "MCP_SERVER_URL": "https://mcp.i18nagent.ai",
+        "API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+## 💡 Usage Tips
+
+### Translation Context
+- **Target Audience**: Specify "technical", "casual", "formal", or "general"
+- **Industry Context**: Use "technology", "healthcare", "finance", "education"
+- **Regional Variations**: Add regions like "Spain", "Mexico", "Brazil"
+
+### File Translation
+- **Preserve Structure**: Keeps original file format and structure
+- **Output Format**: Convert between formats (JSON ↔ YAML ↔ CSV)
+- **Large Files**: Automatically chunks large files for processing
+
+### Credit Management
+- **Cost**: 0.001 credits per word
+- **Monitoring**: Check balance before large translations
+- **Estimates**: Get word count estimates before translation
+
+## 🚨 Troubleshooting
+
+### Installation Issues
+
+**Permission denied:**
+```bash
+sudo npm install -g @i18n-agent/mcp-client
+```
+
+**IDE not detected:**
+```bash
+# Check if IDE directory exists
+ls ~/Library/Application\ Support/Claude/
+ls ~/.cursor/
+ls ~/.vscode/
+```
+
+### Runtime Issues
+
+**API Key not found:**
+```bash
+echo $API_KEY  # Should show your key
+export API_KEY=your-key-here
+```
+
+**Connection errors:**
+- Check your internet connection
+- Verify API key is valid
+- Try again after a few seconds
+
+**Translation quality:**
+- Use Tier 1 languages for production
+- Add context with industry/audience parameters
+- Review Tier 2/3 translations manually
+
+## 📊 Pricing
+
+- **Pay-per-use**: 0.001 credits per word
+- **No subscriptions**: Only pay for what you translate  
+- **Bulk discounts**: Available for enterprise usage
+- **Free tier**: New accounts get starter credits
+
+## 🔐 Privacy & Security
+
+- **No data storage**: Translations are processed in real-time
+- **Encrypted transport**: All data sent over HTTPS
+- **API key security**: Keys are stored locally, never transmitted in logs
+- **GDPR compliant**: EU privacy standards
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md).
+
+### Development Setup
+
+```bash
+git clone https://github.com/i18n-agent/mcp-client.git
+cd mcp-client
+npm install
+npm test
+```
+
+## 📝 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+Copyright (c) 2024 FatCouple OÜ
+
+## 🔗 Links
+
+- **Website**: [i18nagent.ai](https://i18nagent.ai)
+- **Dashboard**: [i18nagent.ai/dashboard](https://i18nagent.ai/dashboard)
+- **Documentation**: [docs.i18nagent.ai](https://docs.i18nagent.ai)
+- **GitHub**: [github.com/i18n-agent/mcp-client](https://github.com/i18n-agent/mcp-client)
+- **Issues**: [github.com/i18n-agent/mcp-client/issues](https://github.com/i18n-agent/mcp-client/issues)
+
+## 🆘 Support
+
+- **Discord**: [Join our community](https://discord.gg/i18nagent)
+- **Email**: support@i18nagent.ai
+- **Documentation**: [docs.i18nagent.ai](https://docs.i18nagent.ai)
+
+---
+
+Made with ❤️ by [FatCouple OÜ](https://fatcouple.com)

package/install.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+/**
+ * i18n-agent MCP Client Installer
+ * Installs the MCP client to work with Claude, Cursor, VS Code and other AI IDEs
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Supported IDE configurations
+const IDE_CONFIGS = {
+  claude: {
+    name: 'Claude Desktop',
+    configPath: path.join(os.homedir(), 'Library/Application Support/Claude/claude_desktop_config.json'),
+    displayPath: '~/Library/Application Support/Claude/claude_desktop_config.json'
+  },
+  cursor: {
+    name: 'Cursor',
+    configPath: path.join(os.homedir(), '.cursor/mcp_settings.json'),
+    displayPath: '~/.cursor/mcp_settings.json'
+  },
+  vscode: {
+    name: 'VS Code (with MCP extension)',
+    configPath: path.join(os.homedir(), '.vscode/mcp_settings.json'),
+    displayPath: '~/.vscode/mcp_settings.json'
+  }
+};
+
+console.log(`
+🌍 i18n-agent MCP Client Installer
+===================================
+
+This installer will set up the i18n-agent MCP client for your AI IDE.
+
+Features:
+✨ Text translation with cultural context
+📁 File translation (JSON, YAML, CSV, MD, etc.)
+💰 Credit balance checking
+🌐 30+ language support with quality tiers
+`);
+
+async function detectAvailableIDEs() {
+  const available = [];
+  
+  for (const [key, config] of Object.entries(IDE_CONFIGS)) {
+    const configDir = path.dirname(config.configPath);
+    if (fs.existsSync(configDir)) {
+      available.push({ key, ...config });
+    }
+  }
+  
+  return available;
+}
+
+function createMCPConfig() {
+  const mcpClientPath = path.resolve(__dirname, 'mcp-client.js');
+  
+  return {
+    mcpServers: {
+      "i18n-agent": {
+        command: "node",
+        args: [mcpClientPath],
+        env: {
+          MCP_SERVER_URL: "https://mcp.i18nagent.ai",
+          API_KEY: ""
+        }
+      }
+    }
+  };
+}
+
+function updateClaudeConfig(configPath) {
+  let config = {};
+  
+  // Read existing config if it exists
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      config = JSON.parse(content);
+    } catch (error) {
+      console.warn(`Warning: Could not parse existing config at ${configPath}`);
+    }
+  }
+  
+  // Ensure mcpServers exists
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  
+  // Add i18n-agent configuration
+  const mcpClientPath = path.resolve(__dirname, 'mcp-client.js');
+  config.mcpServers["i18n-agent"] = {
+    command: "node",
+    args: [mcpClientPath],
+    env: {
+      MCP_SERVER_URL: "https://mcp.i18nagent.ai",
+      API_KEY: ""
+    }
+  };
+  
+  // Write updated config
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  
+  return config;
+}
+
+function updateGenericMCPConfig(configPath) {
+  const config = createMCPConfig();
+  
+  // Write config
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  
+  return config;
+}
+
+async function main() {
+  try {
+    console.log('🔍 Detecting available AI IDEs...\n');
+    
+    const availableIDEs = await detectAvailableIDEs();
+    
+    if (availableIDEs.length === 0) {
+      console.log(`❌ No supported AI IDEs detected.
+
+Supported IDEs:
+- Claude Desktop (macOS)
+- Cursor
+- VS Code (with MCP extension)
+
+Manual setup:
+1. Create the configuration file for your IDE
+2. Add the i18n-agent MCP server configuration
+3. Set your API_KEY environment variable
+
+For manual setup instructions, visit: https://docs.i18nagent.ai/setup
+`);
+      process.exit(1);
+    }
+    
+    console.log('✅ Available AI IDEs:');
+    availableIDEs.forEach((ide, index) => {
+      console.log(`${index + 1}. ${ide.name}`);
+    });
+    
+    console.log('\n📝 Installing for all available IDEs...\n');
+    
+    let installCount = 0;
+    
+    for (const ide of availableIDEs) {
+      try {
+        console.log(`⚙️  Configuring ${ide.name}...`);
+        
+        if (ide.key === 'claude') {
+          updateClaudeConfig(ide.configPath);
+        } else {
+          updateGenericMCPConfig(ide.configPath);
+        }
+        
+        console.log(`✅ ${ide.name} configured successfully!`);
+        console.log(`   Config: ${ide.displayPath}\n`);
+        installCount++;
+        
+      } catch (error) {
+        console.error(`❌ Failed to configure ${ide.name}: ${error.message}\n`);
+      }
+    }
+    
+    if (installCount > 0) {
+      console.log(`🎉 Installation complete! Configured ${installCount} IDE(s).
+
+🔑 Important: Set your API key
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+You need to set your API key to use the translation service:
+
+1. Get your API key from: https://i18nagent.ai/dashboard
+2. Set it as an environment variable:
+
+   export API_KEY=your-api-key-here
+
+   Or add it to your shell profile (~/.bashrc, ~/.zshrc):
+   echo 'export API_KEY=your-api-key-here' >> ~/.zshrc
+
+🔄 Restart your IDE
+After setting the API key, restart your AI IDE to load the new configuration.
+
+🧪 Test the installation
+Try these commands in your AI IDE:
+- "Translate 'Hello world' to Spanish"
+- "Check my translation credits"
+- "List supported languages"
+
+📚 Documentation: https://docs.i18nagent.ai
+🐛 Issues: https://github.com/i18n-agent/mcp-client/issues
+`);
+    } else {
+      console.error('❌ Installation failed for all IDEs. Please check the error messages above.');
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    console.error(`❌ Installation failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// Handle command line execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { main, IDE_CONFIGS, createMCPConfig };

package/mcp-client.js

@@ -0,0 +1,808 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Client for i18n-agent Translation Service
+ * Integrates with Claude Code CLI to provide translation capabilities
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from '@modelcontextprotocol/sdk/types.js';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+
+const server = new Server(
+  {
+    name: 'i18n-agent',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Configuration
+const MCP_SERVER_URL = process.env.MCP_SERVER_URL || 'https://mcp.i18nagent.ai';
+const API_KEY = process.env.API_KEY;
+
+// Validate required environment variables
+if (!API_KEY) {
+  console.error('❌ Error: API_KEY environment variable is required');
+  console.error('💡 Get your API key from: https://i18nagent.ai/dashboard');
+  console.error('💡 Set it with: export API_KEY=your-api-key-here');
+  process.exit(1);
+}
+
+// Available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'translate_text',
+        description: 'Translate text from one language to another with cultural context',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            texts: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Array of texts to translate',
+            },
+            targetLanguage: {
+              type: 'string',
+              description: 'Target language code (e.g., "es", "fr", "ja", "de") or full name (e.g., "Spanish", "French")',
+            },
+            sourceLanguage: {
+              type: 'string',
+              description: 'Source language code (optional, auto-detected if not provided)',
+              default: 'auto',
+            },
+            targetAudience: {
+              type: 'string',
+              description: 'Target audience (e.g., "general", "technical", "casual", "formal")',
+              default: 'general',
+            },
+            industry: {
+              type: 'string',
+              description: 'Industry context (e.g., "technology", "healthcare", "finance", "education")',
+              default: 'technology',
+            },
+            region: {
+              type: 'string',
+              description: 'Specific region for localization (e.g., "Spain", "Mexico", "Brazil")',
+            },
+            notes: {
+              type: 'string',
+              description: 'Optional additional context or instructions for the translation (e.g., "Keep technical terms in English", "Use formal tone")',
+            },
+          },
+          required: ['texts', 'targetLanguage'],
+        },
+      },
+      {
+        name: 'list_supported_languages',
+        description: 'Get list of supported languages with quality ratings',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            includeQuality: {
+              type: 'boolean',
+              description: 'Include quality ratings for each language',
+              default: true,
+            },
+          },
+        },
+      },
+      {
+        name: 'translate_file',
+        description: 'Translate file content while preserving structure and format. Supports JSON, YAML, XML, CSV, TXT, MD, and other text files',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            filePath: {
+              type: 'string',
+              description: 'Path to the file to translate (required if fileContent is not provided)',
+            },
+            fileContent: {
+              type: 'string',
+              description: 'File content as string (required if filePath is not provided)',
+            },
+            fileType: {
+              type: 'string',
+              description: 'File type: json, yaml, yml, xml, csv, txt, md, html, properties',
+              enum: ['json', 'yaml', 'yml', 'xml', 'csv', 'txt', 'md', 'html', 'properties', 'auto'],
+              default: 'auto',
+            },
+            targetLanguage: {
+              type: 'string',
+              description: 'Target language code or name',
+            },
+            targetAudience: {
+              type: 'string',
+              description: 'Target audience',
+              default: 'general',
+            },
+            industry: {
+              type: 'string',
+              description: 'Industry context',
+              default: 'technology',
+            },
+            preserveKeys: {
+              type: 'boolean',
+              description: 'Whether to preserve keys/structure (for structured files)',
+              default: true,
+            },
+            outputFormat: {
+              type: 'string',
+              description: 'Output format: same, json, yaml, txt',
+              default: 'same',
+            },
+            sourceLanguage: {
+              type: 'string',
+              description: 'Source language code (auto-detected if not provided)',
+            },
+            region: {
+              type: 'string',
+              description: 'Specific region for localization (e.g., "Spain", "Mexico", "Brazil")',
+            },
+            notes: {
+              type: 'string',
+              description: 'Optional additional context or instructions for the translation (e.g., "Keep technical terms in English", "Use formal tone")',
+            },
+          },
+          required: ['targetLanguage'],
+        },
+      },
+      {
+        name: 'get_credits',
+        description: 'Get remaining credits for the user and approximate word count available at 0.001 credits per word',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+          required: [],
+        },
+      },
+    ],
+  };
+});
+
+// Tool execution handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'translate_text':
+        return await handleTranslateText(args);
+      
+      case 'list_supported_languages':
+        return await handleListLanguages(args);
+      
+      case 'translate_file':
+        return await handleTranslateFile(args);
+      
+      case 'get_credits':
+        return await handleGetCredits(args);
+      
+      default:
+        throw new McpError(
+          ErrorCode.MethodNotFound,
+          `Unknown tool: ${name}`
+        );
+    }
+  } catch (error) {
+    console.error(`Error executing tool ${name}:`, error);
+    throw new McpError(
+      ErrorCode.InternalError,
+      `Tool execution failed: ${error.message}`
+    );
+  }
+});
+
+async function handleTranslateText(args) {
+  const { texts, targetLanguage, sourceLanguage, targetAudience = 'general', industry = 'technology', region } = args;
+  
+  if (!texts || !Array.isArray(texts) || texts.length === 0) {
+    throw new Error('texts must be a non-empty array');
+  }
+  
+  if (!targetLanguage) {
+    throw new Error('targetLanguage is required');
+  }
+
+  const requestData = {
+    apiKey: API_KEY,
+    texts: texts,
+    targetLanguage: targetLanguage,
+    sourceLanguage: sourceLanguage && sourceLanguage !== 'auto' ? sourceLanguage : undefined,
+    targetAudience: targetAudience,
+    industry: industry,
+    region: region,
+  };
+
+  try {
+    const response = await axios.post(`${MCP_SERVER_URL}/translate`, requestData, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: 60000, // 60 second timeout
+    });
+
+    if (response.data.error) {
+      throw new Error(`Translation service error: ${response.data.error}`);
+    }
+
+    // Direct API response format: { translatedTexts: [...], ... }
+    const parsedResult = response.data;
+    
+    return {
+      translatedTexts: parsedResult?.translatedTexts || [],
+      content: [
+        {
+          type: 'text',
+          text: `Translation Results:\n\n` +
+                `🌍 ${parsedResult?.sourceLanguage || sourceLanguage || 'Auto-detected'} → ${parsedResult?.targetLanguage || targetLanguage}\n` +
+                `👥 Audience: ${parsedResult?.targetAudience || targetAudience}\n` +
+                `🏭 Industry: ${parsedResult?.industry || industry}\n` +
+                `${parsedResult?.region || region ? `📍 Region: ${parsedResult?.region || region}\n` : ''}` +
+                `⏱️ Processing Time: ${parsedResult?.processingTimeMs || 'N/A'}ms\n` +
+                `✅ Valid: ${parsedResult?.isValid !== undefined ? parsedResult.isValid : 'N/A'}\n\n` +
+                `📝 Translations:\n` +
+                (parsedResult?.translatedTexts || []).map((text, index) => 
+                  `${index + 1}. "${(parsedResult?.originalTexts || texts)[index]}" → "${text}"`
+                ).join('\n'),
+        },
+      ],
+    };
+  } catch (error) {
+    if (error.code === 'ECONNABORTED') {
+      throw new Error('Translation request timed out. The service may be processing a large request.');
+    }
+    throw new Error(`Translation service unavailable: ${error.message}`);
+  }
+}
+
+async function handleListLanguages(args) {
+  const { includeQuality = true } = args;
+  
+  // Language support matrix based on GPT-OSS analysis
+  const languages = {
+    'Tier 1 - Production Ready (Excellent Quality 80-90%)': {
+      'en': 'English',
+      'es': 'Spanish', 
+      'fr': 'French',
+      'de': 'German',
+      'it': 'Italian',
+      'pt': 'Portuguese',
+      'nl': 'Dutch',
+    },
+    'Tier 2 - Production Viable (Good Quality 50-75%)': {
+      'ru': 'Russian',
+      'zh-CN': 'Chinese (Simplified)',
+      'ja': 'Japanese',
+      'ko': 'Korean',
+      'ar': 'Arabic',
+      'he': 'Hebrew',
+      'hi': 'Hindi',
+      'pl': 'Polish',
+      'cs': 'Czech',
+    },
+    'Tier 3 - Basic Support (Use with Caution 20-50%)': {
+      'zh-TW': 'Chinese (Traditional)',
+      'th': 'Thai',
+      'vi': 'Vietnamese',
+      'sv': 'Swedish',
+      'da': 'Danish',
+      'no': 'Norwegian',
+      'fi': 'Finnish',
+      'tr': 'Turkish',
+      'hu': 'Hungarian',
+    },
+  };
+
+  let content = '🌍 Supported Languages\n';
+  content += '===================\n\n';
+  
+  if (includeQuality) {
+    for (const [tier, langs] of Object.entries(languages)) {
+      content += `## ${tier}\n`;
+      for (const [code, name] of Object.entries(langs)) {
+        content += `- \`${code}\`: ${name}\n`;
+      }
+      content += '\n';
+    }
+  } else {
+    const allLanguages = Object.values(languages).reduce((acc, tier) => ({ ...acc, ...tier }), {});
+    for (const [code, name] of Object.entries(allLanguages)) {
+      content += `- \`${code}\`: ${name}\n`;
+    }
+  }
+
+  content += '\n💡 Usage Tips:\n';
+  content += '- Use language codes (e.g., "es") or full names (e.g., "Spanish")\n';
+  content += '- Tier 1 languages are recommended for production use\n';
+  content += '- Tier 2 languages work well with human review\n';
+  content += '- Tier 3 languages provide basic translation quality\n';
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: content,
+      },
+    ],
+  };
+}
+
+async function handleTranslateFile(args) {
+  const { 
+    filePath, 
+    fileContent, 
+    fileType = 'auto', 
+    targetLanguage, 
+    targetAudience = 'general', 
+    industry = 'technology',
+    preserveKeys = true,
+    outputFormat = 'same',
+    sourceLanguage,
+    region
+  } = args;
+  
+  if (!filePath && !fileContent) {
+    throw new Error('Either filePath or fileContent must be provided');
+  }
+  
+  if (!targetLanguage) {
+    throw new Error('targetLanguage is required');
+  }
+
+  // Read file content if path provided and no content given
+  let content = fileContent;
+  
+  if (filePath && !fileContent) {
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (error) {
+      throw new Error(`Failed to read file: ${error.message}`);
+    }
+  }
+
+  // Use MCP JSON-RPC protocol for translate_file
+  const mcpRequest = {
+    jsonrpc: '2.0',
+    id: Date.now(),
+    method: 'tools/call',
+    params: {
+      name: 'translate_file',
+      arguments: {
+        apiKey: API_KEY,
+        filePath,
+        fileContent: content,
+        fileType,
+        targetLanguage,
+        sourceLanguage,
+        targetAudience,
+        industry,
+        region,
+        preserveKeys,
+        outputFormat
+      }
+    }
+  };
+
+  try {
+    const response = await axios.post(MCP_SERVER_URL, mcpRequest, {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      timeout: 60000,
+    });
+
+    if (response.data.error) {
+      throw new Error(`Translation service error: ${response.data.error.message || response.data.error}`);
+    }
+
+    // MCP response format
+    const result = response.data.result;
+    return result;
+    
+  } catch (error) {
+    if (error.code === 'ECONNABORTED') {
+      throw new Error('Translation request timed out. The service may be processing a large request.');
+    }
+    throw new Error(`Translation service unavailable: ${error.message}`);
+  }
+}
+
+async function handleGetCredits(args) {
+  try {
+    const response = await axios.post(`${MCP_SERVER_URL}/api/mcp`, {
+      name: 'get_credits',
+      arguments: {
+        apiKey: API_KEY,
+      }
+    }, {
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      timeout: 10000
+    });
+
+    const result = response.data;
+    
+    if (result.isError) {
+      throw new Error(result.content[0].text);
+    }
+
+    const creditsInfo = JSON.parse(result.content[0].text);
+    
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `💰 **Credits Information**
+
+🏢 **Team**: ${creditsInfo.teamName}
+💳 **Credits Remaining**: ${creditsInfo.creditsRemaining}
+📝 **Approximate Words Available**: ${creditsInfo.approximateWordsAvailable.toLocaleString()}
+💵 **Cost per Word**: ${creditsInfo.costPerWord} credits
+⏰ **Last Updated**: ${new Date(creditsInfo.timestamp).toLocaleString()}
+
+Note: Word count is approximate and may vary based on actual content complexity and translation requirements.`,
+        },
+      ],
+    };
+  } catch (error) {
+    console.error('Credits check error:', error);
+    throw new Error(`Unable to check credits: ${error.message}`);
+  }
+}
+
+function detectFileType(filePath, content) {
+  const ext = path.extname(filePath).toLowerCase();
+  
+  switch (ext) {
+    case '.json': return 'json';
+    case '.yaml': case '.yml': return 'yaml';
+    case '.xml': case '.svg': return 'xml';
+    case '.csv': return 'csv';
+    case '.md': return 'md';
+    case '.html': case '.htm': return 'html';
+    case '.properties': return 'properties';
+    case '.txt': return 'txt';
+    default: return detectFileTypeFromContent(content);
+  }
+}
+
+function detectFileTypeFromContent(content) {
+  const trimmed = content.trim();
+  
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try { JSON.parse(trimmed); return 'json'; } catch {}
+  }
+  
+  if (trimmed.match(/^---\s*$|^\s*\w+:\s*[|\->\s]|^\s*\w+:\s*.+$/m)) {
+    return 'yaml';
+  }
+  
+  if (trimmed.startsWith('<') && trimmed.includes('>')) {
+    return 'xml';
+  }
+  
+  if (trimmed.includes(',') && trimmed.split('\n').length > 1) {
+    return 'csv';
+  }
+  
+  if (trimmed.includes('#') || trimmed.includes('**') || trimmed.includes('`')) {
+    return 'md';
+  }
+  
+  if (trimmed.includes('=') && trimmed.split('\n').some(line => line.includes('='))) {
+    return 'properties';
+  }
+  
+  return 'txt';
+}
+
+async function extractTextsFromFile(content, fileType, preserveKeys) {
+  const texts = [];
+  let structure = {};
+
+  switch (fileType) {
+    case 'json':
+      const jsonData = JSON.parse(content);
+      structure = { type: 'json', keys: [] };
+      extractFromJson(jsonData, texts, structure.keys);
+      break;
+      
+    case 'yaml':
+    case 'yml':
+      // Simple YAML parsing - extract values after colons
+      structure = { type: 'yaml', lines: content.split('\n') };
+      const yamlLines = content.split('\n');
+      yamlLines.forEach((line, index) => {
+        const match = line.match(/^(\s*)([^:]+):\s*(.+)$/);
+        if (match && match[3] && !match[3].match(/^[|\->]/)) {
+          const value = match[3].replace(/^["']|["']$/g, '');
+          if (value && !isNumericOrBoolean(value)) {
+            texts.push(value);
+            structure.lines[index] = { original: line, textIndex: texts.length - 1 };
+          }
+        }
+      });
+      break;
+      
+    case 'xml':
+    case 'html':
+      structure = { type: fileType, content: content };
+      // Extract text content between tags
+      const xmlMatches = content.matchAll(/>([^<]+)</g);
+      for (const match of xmlMatches) {
+        const text = match[1].trim();
+        if (text && !isNumericOrBoolean(text)) {
+          texts.push(text);
+        }
+      }
+      break;
+      
+    case 'csv':
+      structure = { type: 'csv', rows: [] };
+      const csvLines = content.split('\n');
+      csvLines.forEach((line, rowIndex) => {
+        if (line.trim()) {
+          const cells = parseCsvLine(line);
+          structure.rows[rowIndex] = [];
+          cells.forEach((cell, colIndex) => {
+            if (cell && !isNumericOrBoolean(cell)) {
+              texts.push(cell);
+              structure.rows[rowIndex][colIndex] = texts.length - 1;
+            } else {
+              structure.rows[rowIndex][colIndex] = null;
+            }
+          });
+        }
+      });
+      break;
+      
+    case 'properties':
+      structure = { type: 'properties', lines: content.split('\n') };
+      const propLines = content.split('\n');
+      propLines.forEach((line, index) => {
+        const match = line.match(/^([^=]+)=(.*)$/);
+        if (match && match[2]) {
+          texts.push(match[2]);
+          structure.lines[index] = { key: match[1], textIndex: texts.length - 1 };
+        }
+      });
+      break;
+      
+    case 'md':
+      structure = { type: 'md', content: content };
+      // Extract text content, avoiding code blocks
+      const mdText = content
+        .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+        .replace(/`[^`]+`/g, '') // Remove inline code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Extract link text
+        .replace(/[#*_`]/g, '') // Remove markdown formatting
+        .split('\n')
+        .filter(line => line.trim())
+        .join(' ');
+      
+      if (mdText.trim()) {
+        texts.push(mdText.trim());
+      }
+      break;
+      
+    default: // txt and others
+      structure = { type: 'txt', content: content };
+      const cleanText = content.trim();
+      if (cleanText) {
+        texts.push(cleanText);
+      }
+      break;
+  }
+
+  return { texts, structure };
+}
+
+function extractFromJson(obj, texts, keys, prefix = '') {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === 'string' && value.trim()) {
+      texts.push(value);
+      keys.push(fullKey);
+    } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      extractFromJson(value, texts, keys, fullKey);
+    } else if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (typeof item === 'string' && item.trim()) {
+          texts.push(item);
+          keys.push(`${fullKey}[${index}]`);
+        } else if (typeof item === 'object' && item !== null) {
+          extractFromJson(item, texts, keys, `${fullKey}[${index}]`);
+        }
+      });
+    }
+  }
+}
+
+function extractTranslatedTexts(translationResult) {
+  const translatedTexts = [];
+  const lines = translationResult.split('\n');
+  const translationSection = lines.findIndex(line => line.includes('📝 Translations:'));
+  
+  if (translationSection !== -1) {
+    for (let i = translationSection + 1; i < lines.length; i++) {
+      const match = lines[i].match(/\d+\. ".*?" → "(.*)"/);
+      if (match) {
+        translatedTexts.push(match[1]);
+      }
+    }
+  }
+  
+  return translatedTexts;
+}
+
+async function reconstructFile(originalContent, translatedTexts, structure, fileType, outputFormat) {
+  const format = outputFormat === 'same' ? fileType : outputFormat;
+  let textIndex = 0;
+
+  switch (format) {
+    case 'json':
+      if (structure.type === 'json') {
+        const jsonData = JSON.parse(originalContent);
+        replaceJsonStrings(jsonData, translatedTexts, textIndex);
+        return JSON.stringify(jsonData, null, 2);
+      } else {
+        // Convert other formats to JSON
+        const jsonObj = {};
+        translatedTexts.forEach((text, i) => {
+          jsonObj[`text_${i + 1}`] = text;
+        });
+        return JSON.stringify(jsonObj, null, 2);
+      }
+      
+    case 'yaml':
+      if (structure.type === 'yaml') {
+        const lines = [...structure.lines];
+        lines.forEach((lineInfo, index) => {
+          if (typeof lineInfo === 'object' && lineInfo.textIndex !== undefined) {
+            const match = lineInfo.original.match(/^(\s*)([^:]+):\s*(.+)$/);
+            if (match) {
+              lines[index] = `${match[1]}${match[2]}: "${translatedTexts[lineInfo.textIndex]}"`;
+            }
+          } else if (typeof lineInfo === 'string') {
+            lines[index] = lineInfo;
+          }
+        });
+        return lines.join('\n');
+      }
+      break;
+      
+    case 'csv':
+      if (structure.type === 'csv') {
+        return structure.rows.map(row => {
+          return row.map(cellIndex => {
+            return cellIndex !== null ? `"${translatedTexts[cellIndex]}"` : '';
+          }).join(',');
+        }).join('\n');
+      }
+      break;
+      
+    case 'properties':
+      if (structure.type === 'properties') {
+        const lines = structure.lines.map(lineInfo => {
+          if (typeof lineInfo === 'object' && lineInfo.textIndex !== undefined) {
+            return `${lineInfo.key}=${translatedTexts[lineInfo.textIndex]}`;
+          }
+          return lineInfo;
+        });
+        return lines.join('\n');
+      }
+      break;
+      
+    case 'txt':
+      return translatedTexts.join('\n\n');
+      
+    default:
+      return translatedTexts.join('\n');
+  }
+
+  // Fallback for unsupported combinations
+  return translatedTexts.join('\n');
+}
+
+function replaceJsonStrings(obj, translatedTexts, startIndex = 0) {
+  let currentIndex = startIndex;
+  
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === 'string' && value.trim()) {
+      if (currentIndex < translatedTexts.length) {
+        obj[key] = translatedTexts[currentIndex];
+        currentIndex++;
+      }
+    } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      currentIndex = replaceJsonStrings(value, translatedTexts, currentIndex);
+    } else if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (typeof item === 'string' && item.trim()) {
+          if (currentIndex < translatedTexts.length) {
+            value[index] = translatedTexts[currentIndex];
+            currentIndex++;
+          }
+        } else if (typeof item === 'object' && item !== null) {
+          currentIndex = replaceJsonStrings(item, translatedTexts, currentIndex);
+        }
+      });
+    }
+  }
+  
+  return currentIndex;
+}
+
+function parseCsvLine(line) {
+  const result = [];
+  let current = '';
+  let inQuotes = false;
+  
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === ',' && !inQuotes) {
+      result.push(current.trim().replace(/^"|"$/g, ''));
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  
+  result.push(current.trim().replace(/^"|"$/g, ''));
+  return result;
+}
+
+function isNumericOrBoolean(value) {
+  return /^\d+$/.test(value) || 
+         /^\d+\.\d+$/.test(value) || 
+         value === 'true' || 
+         value === 'false' ||
+         value === 'null' ||
+         value === 'undefined';
+}
+
+function getCodeBlockLanguage(fileType) {
+  const languageMap = {
+    'json': 'json',
+    'yaml': 'yaml',
+    'yml': 'yaml', 
+    'xml': 'xml',
+    'html': 'html',
+    'csv': 'csv',
+    'md': 'markdown',
+    'properties': 'properties',
+    'txt': 'text'
+  };
+  return languageMap[fileType] || 'text';
+}
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('i18n-agent MCP server running...');
+  console.error('MCP_SERVER_URL:', MCP_SERVER_URL);
+  console.error('API_KEY:', API_KEY ? 'Set ✓' : 'Not set ✗');
+}
+
+main().catch((error) => {
+  console.error('Failed to start server:', error);
+  process.exit(1);
+});

package/package.json

@@ -1,29 +1,51 @@
 {
   "name": "@i18n-agent/mcp-client",
-  "version": "1.0.0",
-  "description": "Easy installation and setup of i18n-agent MCP client for AI development environments",
-  "main": "index.js",
+  "version": "1.0.1",
+  "description": "MCP client for i18n-agent translation service - supports Claude, Cursor, VS Code, and other AI IDEs",
+  "main": "mcp-client.js",
   "bin": {
-    "i18n-agent-mcp": "index.js"
+    "i18n-agent-install": "./install.js"
   },
+  "type": "module",
   "scripts": {
-    "start": "node index.js"
+    "install": "node install.js",
+    "test": "node test.js",
+    "postinstall": "echo '\n🌍 i18n-agent MCP Client installed successfully!\n💡 Run: npx @i18n-agent/mcp-client install\n'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/i18n-agent/mcp-client.git"
   },
   "keywords": [
     "i18n",
     "translation",
     "mcp",
-    "claude-code", 
-    "gemini",
+    "claude",
     "cursor",
-    "ai"
+    "vscode",
+    "ai",
+    "internationalization",
+    "localization"
   ],
-  "author": "i18n Agent Team",
+  "author": "FatCouple OÜ",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/i18n-agent/mcp-client.git"
+  "bugs": {
+    "url": "https://github.com/i18n-agent/mcp-client/issues"
+  },
+  "homepage": "https://i18nagent.ai",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0"
   },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "mcp-client.js",
+    "install.js",
+    "README.md",
+    "LICENSE"
+  ],
   "publishConfig": {
     "access": "public"
   }

package/index.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-console.log('⚠️  Please use: npx i18n-agent-mcp-client install');
-console.log('📖 Documentation: https://github.com/i18n-agent/mcp-client');
-console.log('');
-console.log('This package redirects to the main installer.');
-console.log('The scoped package @i18n-agent/mcp-client is a placeholder.');
-process.exit(1);