@i18n-agent/cli 1.0.1

package/src/index.js

@@ -0,0 +1,156 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { loginAction } from './commands/login.js';
+import { logoutAction } from './commands/logout.js';
+import { creditsAction } from './commands/credits.js';
+import { languagesAction } from './commands/languages.js';
+import { translateAction, translateTextAction, translateFileAction } from './commands/translate.js';
+import { statusAction } from './commands/status.js';
+import { downloadAction } from './commands/download.js';
+import { resumeAction } from './commands/resume.js';
+import { uploadAction, uploadsListAction } from './commands/upload.js';
+import { analyzeAction } from './commands/analyze.js';
+import { tuiAction } from './commands/tui.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getVersion() {
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  return pkg.version;
+}
+
+export function createProgram() {
+  const program = new Command();
+
+  program
+    .name('i18nagent')
+    .description('Terminal client for i18n-agent translation service')
+    .version(getVersion());
+
+  // --- Auth ---
+
+  program
+    .command('login')
+    .description('Save API key to config file')
+    .option('--key <key>', 'API key (or enter interactively)')
+    .option('--force', 'Overwrite existing key')
+    .action(loginAction);
+
+  program
+    .command('logout')
+    .description('Remove saved API key')
+    .action(logoutAction);
+
+  // --- Translation ---
+
+  const addTranslateOpts = (cmd) => cmd
+    .option('--lang <languages>', 'Target language(s), comma-separated (e.g. es,fr,ja)')
+    .option('--source <lang>', 'Source language (auto-detected if omitted)')
+    .option('--audience <audience>', 'Target audience (e.g. general, technical)')
+    .option('--industry <industry>', 'Industry context (e.g. technology, healthcare)')
+    .option('--context <context>', 'Additional instructions for translation')
+    .option('--namespace <ns>', 'Namespace for project tracking')
+    .option('--pseudo', 'Pseudo-translation mode (no AI cost)')
+    .option('--skip-warnings', 'Skip source quality warnings')
+    .option('--output <dir>', 'Output directory for file translations')
+    .option('--json', 'Output as JSON');
+
+  const translate = program
+    .command('translate [input]')
+    .description('Translate text or file (auto-detected). Run without args for interactive mode.');
+  addTranslateOpts(translate).action(translateAction);
+
+  const translateTextCmd = translate
+    .command('text [text]')
+    .description('Translate text content');
+  addTranslateOpts(translateTextCmd).action(translateTextAction);
+
+  const translateFileCmd = translate
+    .command('file [path]')
+    .description('Translate a file');
+  addTranslateOpts(translateFileCmd).action(translateFileAction);
+
+  // --- Job management ---
+
+  program
+    .command('status <jobId>')
+    .description('Check translation job status')
+    .option('--json', 'Output as JSON')
+    .option('--page-size <n>', 'Languages per page (default: 50)')
+    .action(statusAction);
+
+  program
+    .command('download <jobId>')
+    .description('Download completed translations')
+    .option('--output <dir>', 'Output directory')
+    .option('--json', 'Output as JSON')
+    .action(downloadAction);
+
+  program
+    .command('resume <jobId>')
+    .description('Resume a failed or interrupted translation job')
+    .option('--json', 'Output as JSON')
+    .action(resumeAction);
+
+  // --- Upload ---
+
+  program
+    .command('upload [filePath]')
+    .description('Upload existing translations for reuse')
+    .requiredOption('--source <lang>', 'Source language code')
+    .requiredOption('--target <lang>', 'Target language code')
+    .option('--namespace <ns>', 'Namespace for tracking')
+    .option('--json', 'Output as JSON')
+    .action(uploadAction);
+
+  const uploads = program
+    .command('uploads')
+    .description('Manage uploaded translations');
+
+  uploads
+    .command('list')
+    .description('List uploaded translations in a namespace')
+    .requiredOption('--namespace <ns>', 'Namespace to list')
+    .option('--source <lang>', 'Filter by source language')
+    .option('--target <lang>', 'Filter by target language')
+    .option('--json', 'Output as JSON')
+    .action(uploadsListAction);
+
+  // --- Info ---
+
+  program
+    .command('credits')
+    .description('Check translation credit balance')
+    .option('--json', 'Output as JSON')
+    .action(creditsAction);
+
+  program
+    .command('languages')
+    .description('List supported languages')
+    .option('--json', 'Output as JSON')
+    .option('--no-quality', 'Exclude quality ratings')
+    .action(languagesAction);
+
+  program
+    .command('analyze <input>')
+    .description('Analyze content for translation readiness')
+    .requiredOption('--lang <lang>', 'Target language')
+    .option('--source <lang>', 'Source language')
+    .option('--audience <audience>', 'Target audience')
+    .option('--industry <industry>', 'Industry context')
+    .option('--json', 'Output as JSON')
+    .action(analyzeAction);
+
+  // --- Interactive ---
+
+  program
+    .command('tui')
+    .description('Launch interactive TUI mode')
+    .action(tuiAction);
+
+  return program;
+}

package/src/namespace-detector.js

@@ -0,0 +1,362 @@
+/**
+ * Namespace Auto-Detection Utility for MCP Client
+ *
+ * Analyzes file paths and suggests namespace names based on project structure.
+ * Follows the same validation rules as the service-mcp namespace validator.
+ */
+
+/**
+ * Auto-detect namespace from file path
+ */
+export function detectNamespaceFromPath(filePath, options = {}) {
+  const { includeAlternatives = true, maxAlternatives = 3 } = options;
+
+  if (!filePath || typeof filePath !== 'string') {
+    return {
+      suggestion: null,
+      confidence: 0,
+      source: 'none',
+      reasoning: 'No file path provided',
+      alternatives: []
+    };
+  }
+
+  // Normalize path separators
+  const normalizedPath = filePath.replace(/\\/g, '/');
+  const pathSegments = normalizedPath.split('/').filter(segment => segment.length > 0);
+
+  // Pattern detection strategies (ordered by confidence)
+  const detectionStrategies = [
+    detectServicePattern,
+    detectGitRepoPattern,
+    detectProjectFolderPattern,
+    detectDirectoryPattern
+  ];
+
+  let bestResult = null;
+  const allSuggestions = [];
+
+  for (const strategy of detectionStrategies) {
+    const result = strategy(pathSegments, normalizedPath);
+    if (result.suggestion && isValidNamespace(result.suggestion)) {
+      if (!bestResult || result.confidence > bestResult.confidence) {
+        bestResult = result;
+      }
+      if (includeAlternatives && !allSuggestions.includes(result.suggestion)) {
+        allSuggestions.push(result.suggestion);
+      }
+    }
+  }
+
+  if (!bestResult) {
+    return {
+      suggestion: null,
+      confidence: 0,
+      source: 'none',
+      reasoning: 'Could not detect a valid namespace from the file path',
+      alternatives: []
+    };
+  }
+
+  // Generate alternatives
+  const alternatives = includeAlternatives
+    ? allSuggestions
+        .filter(s => s !== bestResult.suggestion)
+        .slice(0, maxAlternatives)
+    : [];
+
+  return {
+    ...bestResult,
+    alternatives
+  };
+}
+
+/**
+ * Detect service-* pattern (highest confidence)
+ * Examples:
+ * - /path/to/service-platform/file.json → "service-platform"
+ * - /path/to/service-auth/config.yaml → "service-auth"
+ */
+function detectServicePattern(pathSegments) {
+  for (let i = 0; i < pathSegments.length; i++) {
+    const segment = pathSegments[i];
+    if (segment.startsWith('service-') && segment.length > 8) {
+      const serviceName = segment.toLowerCase();
+      return {
+        suggestion: serviceName,
+        confidence: 0.9,
+        source: 'service-name',
+        reasoning: `Detected service name "${serviceName}" in path`,
+        alternatives: []
+      };
+    }
+  }
+
+  return { suggestion: null, confidence: 0, source: 'none', reasoning: '', alternatives: [] };
+}
+
+/**
+ * Detect git repository pattern (high confidence)
+ * Examples:
+ * - /path/to/i18n-agent/service-platform/file.json → "service-platform"
+ * - /path/to/my-project/src/file.ts → "my-project"
+ */
+function detectGitRepoPattern(pathSegments) {
+  // Look for common project root indicators
+  const projectRootIndicators = [
+    'package.json', '.git', 'node_modules', 'src', 'lib', 'app',
+    'components', 'pages', 'public', 'assets', 'docs', 'tests'
+  ];
+
+  // Find potential project root by looking for these indicators
+  for (let i = pathSegments.length - 1; i >= 0; i--) {
+    const segment = pathSegments[i];
+
+    // If this looks like a project folder, use it
+    if (segment.includes('-') || segment.includes('_')) {
+      // Check if next segments contain project indicators
+      const remainingPath = pathSegments.slice(i + 1);
+      const hasProjectIndicators = remainingPath.some(seg =>
+        projectRootIndicators.includes(seg) ||
+        seg === 'src' ||
+        seg === 'lib' ||
+        seg.includes('component') ||
+        seg.includes('page')
+      );
+
+      if (hasProjectIndicators) {
+        const suggestion = normalizeNamespace(segment);
+        if (suggestion) {
+          return {
+            suggestion,
+            confidence: 0.7,
+            source: 'git-repo',
+            reasoning: `Detected project root "${segment}" based on directory structure`,
+            alternatives: []
+          };
+        }
+      }
+    }
+  }
+
+  return { suggestion: null, confidence: 0, source: 'none', reasoning: '', alternatives: [] };
+}
+
+/**
+ * Detect project folder pattern (medium confidence)
+ * Examples:
+ * - /Users/user/Documents/my-awesome-project/file.js → "my-awesome-project"
+ * - /workspace/client-docs/locales/en.json → "client-docs"
+ */
+function detectProjectFolderPattern(pathSegments) {
+  // Look for segments that contain hyphens or underscores (common in project names)
+  const projectLikeSegments = pathSegments.filter(segment =>
+    (segment.includes('-') || segment.includes('_')) &&
+    segment.length >= 3 &&
+    !segment.startsWith('.') &&
+    segment !== 'node_modules'
+  );
+
+  if (projectLikeSegments.length > 0) {
+    // Use the last project-like segment (closest to the file)
+    const lastProjectSegment = projectLikeSegments[projectLikeSegments.length - 1];
+    const suggestion = normalizeNamespace(lastProjectSegment);
+
+    if (suggestion) {
+      return {
+        suggestion,
+        confidence: 0.5,
+        source: 'project-folder',
+        reasoning: `Detected project-like folder "${lastProjectSegment}" in path`,
+        alternatives: []
+      };
+    }
+  }
+
+  return { suggestion: null, confidence: 0, source: 'none', reasoning: '', alternatives: [] };
+}
+
+/**
+ * Detect directory pattern (low confidence fallback)
+ * Uses the immediate parent directory if it looks reasonable
+ */
+function detectDirectoryPattern(pathSegments) {
+  if (pathSegments.length < 2) {
+    return { suggestion: null, confidence: 0, source: 'none', reasoning: '', alternatives: [] };
+  }
+
+  // Use the parent directory of the file
+  const parentDir = pathSegments[pathSegments.length - 2];
+  const suggestion = normalizeNamespace(parentDir);
+
+  if (suggestion && suggestion.length >= 3) {
+    return {
+      suggestion,
+      confidence: 0.3,
+      source: 'directory-name',
+      reasoning: `Using parent directory "${parentDir}" as fallback`,
+      alternatives: []
+    };
+  }
+
+  return { suggestion: null, confidence: 0, source: 'none', reasoning: '', alternatives: [] };
+}
+
+/**
+ * Normalize a potential namespace to follow validation rules
+ */
+function normalizeNamespace(input) {
+  if (!input || typeof input !== 'string') return null;
+
+  // Convert to lowercase and trim
+  let normalized = input.toLowerCase().trim();
+
+  // Replace invalid characters with hyphens
+  normalized = normalized.replace(/[^a-z0-9_-]/g, '-');
+
+  // Remove multiple consecutive hyphens/underscores
+  normalized = normalized.replace(/[-_]{2,}/g, '-');
+
+  // Remove leading/trailing hyphens or underscores
+  normalized = normalized.replace(/^[-_]+|[-_]+$/g, '');
+
+  // Check length constraints
+  if (normalized.length < 3 || normalized.length > 50) {
+    return null;
+  }
+
+  // Check if it's a reserved keyword
+  const reservedKeywords = [
+    'admin', 'api', 'www', 'system', 'root', 'default',
+    'translations', 'upload', 'download', 'temp', 'cache',
+    'public', 'private', 'test', 'staging', 'production'
+  ];
+
+  if (reservedKeywords.includes(normalized)) {
+    return null;
+  }
+
+  return normalized;
+}
+
+/**
+ * Quick validation using the same rules as service-mcp
+ */
+function isValidNamespace(namespace) {
+  if (!namespace || typeof namespace !== 'string') return false;
+
+  // Basic validation
+  const pattern = /^[a-z0-9_-]+$/;
+  return (
+    namespace.length >= 3 &&
+    namespace.length <= 50 &&
+    pattern.test(namespace) &&
+    !['admin', 'api', 'www', 'system', 'root', 'default'].includes(namespace)
+  );
+}
+
+/**
+ * Generate additional namespace suggestions based on file context
+ */
+export function generateNamespaceSuggestions(fileName, fileContent) {
+  const suggestions = [];
+
+  if (fileName) {
+    // Extract potential namespace from filename
+    const baseName = fileName.replace(/\.(json|yaml|yml|ts|js|md)$/i, '');
+    const normalized = normalizeNamespace(baseName);
+    if (normalized) {
+      suggestions.push(normalized);
+    }
+
+    // Look for common patterns in filename
+    if (fileName.includes('i18n') || fileName.includes('locale') || fileName.includes('lang')) {
+      suggestions.push('localization', 'translations', 'i18n-project');
+    }
+
+    if (fileName.includes('api') || fileName.includes('endpoint')) {
+      suggestions.push('api-docs', 'api-project');
+    }
+
+    if (fileName.includes('component') || fileName.includes('ui')) {
+      suggestions.push('components', 'ui-library');
+    }
+  }
+
+  if (fileContent) {
+    // Analyze content for clues (basic implementation)
+    const content = fileContent.toLowerCase();
+
+    if (content.includes('api') || content.includes('endpoint')) {
+      suggestions.push('api-docs');
+    }
+
+    if (content.includes('component') || content.includes('react') || content.includes('vue')) {
+      suggestions.push('components');
+    }
+
+    if (content.includes('translation') || content.includes('locale')) {
+      suggestions.push('translations');
+    }
+  }
+
+  // Remove duplicates and filter valid ones
+  return [...new Set(suggestions)]
+    .filter(s => isValidNamespace(s))
+    .slice(0, 5);
+}
+
+/**
+ * Get helpful namespace suggestions text for user guidance
+ */
+export function getNamespaceSuggestionText(filePath, fileName) {
+  if (!filePath && !fileName) {
+    return `💡 Namespace Suggestions:
+• Use descriptive project names: "my-website", "mobile-app"
+• Include service names: "service-auth", "api-gateway"
+• Use organization prefixes: "company-docs", "team-frontend"
+• Avoid generic names: "app", "project", "files"`;
+  }
+
+  const detection = detectNamespaceFromPath(filePath || fileName);
+
+  if (detection.suggestion) {
+    let text = `🎯 Auto-detected suggestion: "${detection.suggestion}"`;
+    text += `\n📍 Source: ${getSourceDescription(detection.source)}`;
+    text += `\n💪 Confidence: ${Math.round(detection.confidence * 100)}%`;
+
+    if (detection.alternatives.length > 0) {
+      text += `\n🔄 Alternatives: ${detection.alternatives.join(', ')}`;
+    }
+
+    return text;
+  }
+
+  return `💡 Namespace Suggestions for "${fileName || filePath}":
+• Extract from path: "${getPathBasedSuggestion(filePath || fileName)}"
+• Use project context: "docs", "website", "api"
+• Include team/org: "frontend-team", "backend-api"
+• Keep it descriptive: "user-dashboard", "admin-panel"`;
+}
+
+function getSourceDescription(source) {
+  const descriptions = {
+    'service-name': 'Service name pattern detected',
+    'git-repo': 'Git repository structure analyzed',
+    'project-folder': 'Project folder pattern found',
+    'directory-name': 'Parent directory used as fallback'
+  };
+  return descriptions[source] || 'Unknown source';
+}
+
+function getPathBasedSuggestion(path) {
+  if (!path) return 'my-project';
+
+  const segments = path.replace(/\\/g, '/').split('/').filter(s => s.length > 0);
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const normalized = normalizeNamespace(segments[i]);
+    if (normalized) return normalized;
+  }
+
+  return 'my-project';
+}

package/src/output.js

@@ -0,0 +1,39 @@
+export function formatOutput(data, opts = {}) {
+  if (opts.json) {
+    return JSON.stringify(data, null, 2);
+  }
+  if (opts.template) {
+    return opts.template(data);
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+export function formatError(message, opts = {}) {
+  if (opts.json) {
+    return JSON.stringify({ error: message });
+  }
+  return `Error: ${message}`;
+}
+
+export function formatSuccess(message, opts = {}) {
+  if (opts.json) {
+    return JSON.stringify({ success: true, message });
+  }
+  return message;
+}
+
+export function formatProgress(current, total, width = 20) {
+  const pct = total > 0 ? Math.round((current / total) * 100) : 0;
+  const filled = Math.round((pct / 100) * width);
+  const empty = width - filled;
+  const bar = '#'.repeat(filled) + '.'.repeat(empty);
+  return `[${bar}] ${pct}%`;
+}
+
+export function print(text) {
+  process.stdout.write(text + '\n');
+}
+
+export function printErr(text) {
+  process.stderr.write(text + '\n');
+}

package/src/prompts.js

@@ -0,0 +1,65 @@
+import readline from 'readline';
+
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+}
+
+function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+export async function promptText(question) {
+  const rl = createInterface();
+  try {
+    const answer = await ask(rl, question);
+    return answer || null;
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptApiKey() {
+  const rl = createInterface();
+  try {
+    const key = await ask(rl, 'Enter your API key (get one at https://app.i18nagent.ai): ');
+    if (!key) return null;
+    if (!key.startsWith('i18n_') || key.length <= 5) {
+      console.error('Invalid API key format. Keys should start with "i18n_"');
+      return null;
+    }
+    return key;
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptChoice(question, choices) {
+  const rl = createInterface();
+  try {
+    console.error(question);
+    choices.forEach((choice, i) => {
+      console.error(`  [${i + 1}] ${choice}`);
+    });
+    const answer = await ask(rl, '\n  Choose: ');
+    const num = parseInt(answer, 10);
+    if (isNaN(num) || num < 1 || num > choices.length) return null;
+    return num - 1;
+  } finally {
+    rl.close();
+  }
+}
+
+export async function promptConfirm(question) {
+  const rl = createInterface();
+  try {
+    const answer = await ask(rl, `${question} (y/n): `);
+    return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+  } finally {
+    rl.close();
+  }
+}