@i18n-agent/cli 1.0.1

package/src/commands/status.js

@@ -0,0 +1,44 @@
+import { requireApiKey } from '../config.js';
+import { callTool } from '../api-client.js';
+import { formatOutput, formatProgress, print } from '../output.js';
+
+export async function statusAction(jobId, opts) {
+  if (!jobId) {
+    console.error('Error: jobId is required');
+    console.error('Usage: i18nagent status <jobId>');
+    process.exit(1);
+  }
+
+  const apiKey = requireApiKey();
+
+  try {
+    const result = await callTool('check_translation_status', {
+      jobId,
+      pageSize: opts.pageSize ? parseInt(opts.pageSize) : 50,
+    }, apiKey, { timeout: 30000 });
+
+    print(formatOutput(result, {
+      json: opts.json,
+      template: (data) => {
+        const lines = [`Job: ${jobId}`];
+        lines.push(`Status: ${data.status || 'unknown'}`);
+        if (data.progress !== undefined) {
+          lines.push(`Progress: ${formatProgress(data.progress, 100)}`);
+        }
+        if (data.elapsedTime) {
+          lines.push(`Elapsed: ${data.elapsedTime}`);
+        }
+        if (data.completedLanguages?.length) {
+          lines.push(`Completed: ${data.completedLanguages.join(', ')}`);
+        }
+        if (data.status === 'completed') {
+          lines.push('\nDownload with: i18nagent download ' + jobId);
+        }
+        return lines.join('\n');
+      }
+    }));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/translate.js

@@ -0,0 +1,301 @@
+import fs from 'fs';
+import path from 'path';
+import { requireApiKey, loadConfig, getConfigPath } from '../config.js';
+import { callTool } from '../api-client.js';
+import { formatOutput, formatProgress, print, printErr } from '../output.js';
+import { promptText, promptChoice } from '../prompts.js';
+import { detectNamespaceFromPath } from '../namespace-detector.js';
+
+function isFilePath(input) {
+  if (!input) return false;
+  if (fs.existsSync(input)) return true;
+  const ext = path.extname(input);
+  if (ext && !input.includes(' ')) return true;
+  return false;
+}
+
+function parseLanguages(langStr) {
+  if (!langStr) return null;
+  return langStr.split(',').map(l => l.trim()).filter(Boolean);
+}
+
+async function interactiveTranslate(opts) {
+  const modeIdx = await promptChoice('What would you like to translate?', [
+    'Text',
+    'File',
+  ]);
+  if (modeIdx === null) return;
+
+  if (modeIdx === 0) {
+    const text = await promptText('Enter text to translate: ');
+    if (!text) return;
+    const lang = await promptText('Target language(s) (comma-separated, e.g. es,fr): ');
+    if (!lang) return;
+    opts.lang = lang;
+    return translateText([text], opts);
+  } else {
+    const filePath = await promptText('File path: ');
+    if (!filePath) return;
+    const lang = await promptText('Target language(s) (comma-separated, e.g. es,fr): ');
+    if (!lang) return;
+    opts.lang = lang;
+    return translateFile(filePath, opts);
+  }
+}
+
+export async function translateAction(input, opts) {
+  if (!input) {
+    return interactiveTranslate(opts);
+  }
+  if (isFilePath(input)) {
+    return translateFile(input, opts);
+  } else {
+    return translateText([input], opts);
+  }
+}
+
+export async function translateTextAction(text, opts) {
+  if (!text) {
+    const input = await promptText('Enter text to translate: ');
+    if (!input) return;
+    text = input;
+  }
+  return translateText([text], opts);
+}
+
+export async function translateFileAction(filePath, opts) {
+  if (!filePath) {
+    const input = await promptText('File path: ');
+    if (!input) return;
+    filePath = input;
+  }
+  return translateFile(filePath, opts);
+}
+
+async function translateText(texts, opts) {
+  const apiKey = requireApiKey();
+  const languages = parseLanguages(opts.lang);
+  if (!languages) {
+    printErr('Error: --lang is required (e.g. --lang es,fr,ja)');
+    process.exit(1);
+  }
+
+  const args = {
+    texts,
+    targetLanguages: languages,
+  };
+  if (opts.source) args.sourceLanguage = opts.source;
+  if (opts.audience) args.targetAudience = opts.audience;
+  if (opts.industry) args.industry = opts.industry;
+  if (opts.context) args.context = opts.context;
+  if (opts.namespace) args.namespace = opts.namespace;
+  if (opts.pseudo) args.pseudoTranslation = true;
+  if (opts.skipWarnings) args.skipWarnings = true;
+
+  try {
+    const result = await callTool('translate_text', args, apiKey, {
+      timeout: texts.join('').length > 50000 ? 600000 : 300000,
+    });
+
+    if (result.status === 'processing' && result.jobId) {
+      printErr(`Job started: ${result.jobId}`);
+      printErr('Polling for completion...\n');
+      return pollAndDownload(result.jobId, apiKey, opts);
+    }
+
+    print(formatOutput(result, {
+      json: opts.json,
+      template: formatTranslationResult,
+    }));
+  } catch (error) {
+    if (opts.json) {
+      print(JSON.stringify({ error: error.message }));
+    } else {
+      printErr(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+async function translateFile(filePath, opts) {
+  const apiKey = requireApiKey();
+  const languages = parseLanguages(opts.lang);
+  if (!languages) {
+    printErr('Error: --lang is required (e.g. --lang es,fr,ja)');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(filePath)) {
+    printErr(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const ext = path.extname(filePath).slice(1) || 'auto';
+
+  let namespace = opts.namespace;
+  if (!namespace) {
+    const config = loadConfig(getConfigPath());
+    namespace = config.defaultNamespace;
+  }
+  if (!namespace) {
+    const detection = detectNamespaceFromPath(path.resolve(filePath));
+    if (detection.suggestion && detection.confidence > 0.5) {
+      namespace = detection.suggestion;
+      printErr(`Auto-detected namespace: "${namespace}"`);
+    }
+  }
+  if (!namespace) {
+    namespace = await promptText('Namespace (required for file translation): ');
+    if (!namespace) {
+      printErr('Error: namespace is required for file translation');
+      process.exit(1);
+    }
+  }
+
+  const args = {
+    fileContent: content,
+    filePath,
+    fileType: ext,
+    targetLanguages: languages,
+    namespace,
+  };
+  if (opts.source) args.sourceLanguage = opts.source;
+  if (opts.audience) args.targetAudience = opts.audience;
+  if (opts.industry) args.industry = opts.industry;
+  if (opts.context) args.context = opts.context;
+  if (opts.pseudo) args.pseudoTranslation = true;
+  if (opts.skipWarnings) args.skipWarnings = true;
+
+  printErr(`Translating ${path.basename(filePath)} -> ${languages.join(', ')}...`);
+
+  try {
+    const result = await callTool('translate_file', args, apiKey, {
+      timeout: content.length > 50000 ? 600000 : 300000,
+    });
+
+    if (result.jobId) {
+      printErr(`Job ID: ${result.jobId}\n`);
+      return pollAndDownload(result.jobId, apiKey, opts);
+    }
+
+    print(formatOutput(result, { json: opts.json }));
+  } catch (error) {
+    if (opts.json) {
+      print(JSON.stringify({ error: error.message }));
+    } else {
+      printErr(`Error: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+async function pollAndDownload(jobId, apiKey, opts) {
+  const startTime = Date.now();
+  const maxWait = 600000;
+
+  while (Date.now() - startTime < maxWait) {
+    try {
+      const status = await callTool('check_translation_status', {
+        jobId,
+        pageSize: 50,
+      }, apiKey, { timeout: 30000 });
+
+      const progress = status.progress || 0;
+      const statusText = status.status || 'unknown';
+
+      if (!opts.json) {
+        const bar = formatProgress(progress, 100);
+        const completed = status.completedLanguages?.join(', ') || '';
+        printErr(`\r  ${bar} | ${statusText}${completed ? ' | Done: ' + completed : ''}    `);
+      }
+
+      if (statusText === 'completed' || progress === 100) {
+        if (!opts.json) printErr('\n');
+        return downloadResults(jobId, apiKey, opts);
+      }
+
+      if (statusText === 'failed') {
+        if (!opts.json) printErr('\n');
+        const msg = status.error || 'Translation failed';
+        printErr(`Error: ${msg}`);
+        process.exit(1);
+      }
+
+      await new Promise(r => setTimeout(r, 5000));
+    } catch (error) {
+      printErr(`\nError checking status: ${error.message}`);
+      printErr(`Check manually: i18nagent status ${jobId}`);
+      process.exit(1);
+    }
+  }
+
+  printErr(`\nTimeout waiting for job. Check status: i18nagent status ${jobId}`);
+  process.exit(1);
+}
+
+async function downloadResults(jobId, apiKey, opts) {
+  try {
+    const result = await callTool('download_translations', { jobId }, apiKey, { timeout: 60000 });
+
+    const outputDir = opts.output || `./i18n-translations-${jobId}`;
+    fs.mkdirSync(outputDir, { recursive: true });
+
+    const filesWritten = [];
+
+    if (result.downloadUrls) {
+      for (const [lang, url] of Object.entries(result.downloadUrls)) {
+        const response = await fetch(url);
+        const content = await response.text();
+        const ext = result.fileName?.split('.').pop() || 'json';
+        const fp = path.join(outputDir, `${lang}.${ext}`);
+        fs.writeFileSync(fp, content);
+        filesWritten.push(fp);
+      }
+    } else if (result.translations) {
+      for (const [lang, content] of Object.entries(result.translations)) {
+        const ext = result.fileName?.split('.').pop() || 'json';
+        const fp = path.join(outputDir, `${lang}.${ext}`);
+        fs.writeFileSync(fp, content);
+        filesWritten.push(fp);
+      }
+    }
+
+    if (opts.json) {
+      print(JSON.stringify({ jobId, outputDir, filesWritten }, null, 2));
+    } else {
+      print(`Translation complete! Files saved to:\n${filesWritten.map(f => `  ${f}`).join('\n')}`);
+    }
+  } catch (error) {
+    printErr(`Error downloading: ${error.message}`);
+    printErr(`Download manually: i18nagent download ${jobId}`);
+    process.exit(1);
+  }
+}
+
+function formatTranslationResult(data) {
+  if (!data) return 'No result';
+  const lines = ['Translation complete\n'];
+
+  if (data.translations) {
+    if (Array.isArray(data.translations)) {
+      for (const t of data.translations) {
+        lines.push(`  ${t.language || t.lang}: "${t.text || t.translation}"`);
+      }
+    } else if (typeof data.translations === 'object') {
+      for (const [lang, texts] of Object.entries(data.translations)) {
+        if (Array.isArray(texts)) {
+          lines.push(`  ${lang}: ${texts.map(t => `"${t}"`).join(', ')}`);
+        } else {
+          lines.push(`  ${lang}: "${texts}"`);
+        }
+      }
+    }
+  }
+
+  if (data.creditsUsed !== undefined) {
+    lines.push(`\n  Credits used: ${data.creditsUsed}`);
+  }
+
+  return lines.join('\n');
+}

package/src/commands/tui.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { promptChoice, promptText } from '../prompts.js';
+import { translateAction } from './translate.js';
+import { statusAction } from './status.js';
+import { creditsAction } from './credits.js';
+import { loginAction } from './login.js';
+import { printErr } from '../output.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 async function tuiAction() {
+  console.error(`\ni18n-agent CLI v${getVersion()}\n`);
+
+  while (true) {
+    const choice = await promptChoice('What would you like to do?', [
+      'Translate text',
+      'Translate file',
+      'Check job status',
+      'View credits',
+      'Upload translations',
+      'Settings (login/logout)',
+      'Exit',
+    ]);
+
+    if (choice === null || choice === 6) {
+      break;
+    }
+
+    try {
+      switch (choice) {
+        case 0: {
+          const text = await promptText('\nEnter text to translate: ');
+          if (!text) break;
+          const lang = await promptText('Target language(s) (e.g. es,fr): ');
+          if (!lang) break;
+          await translateAction(text, { lang });
+          break;
+        }
+        case 1: {
+          const filePath = await promptText('\nFile path: ');
+          if (!filePath) break;
+          const lang = await promptText('Target language(s) (e.g. es,fr): ');
+          if (!lang) break;
+          await translateAction(filePath, { lang });
+          break;
+        }
+        case 2: {
+          const jobId = await promptText('\nJob ID: ');
+          if (!jobId) break;
+          await statusAction(jobId, {});
+          break;
+        }
+        case 3: {
+          await creditsAction({});
+          break;
+        }
+        case 4: {
+          printErr('\nUse: i18nagent upload <file> --source <lang> --target <lang>');
+          break;
+        }
+        case 5: {
+          const settingChoice = await promptChoice('\nSettings:', [
+            'Login (save API key)',
+            'Logout (remove API key)',
+            'Back',
+          ]);
+          if (settingChoice === 0) await loginAction({});
+          if (settingChoice === 1) {
+            const { logoutAction } = await import('./logout.js');
+            await logoutAction();
+          }
+          break;
+        }
+      }
+    } catch (error) {
+      printErr(`\nError: ${error.message}\n`);
+    }
+
+    console.error('');
+  }
+
+  console.error('Goodbye!');
+}

package/src/commands/upload.js

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import path from 'path';
+import { requireApiKey, loadConfig, getConfigPath } from '../config.js';
+import { callTool, uploadFile } from '../api-client.js';
+import { formatOutput, print, printErr } from '../output.js';
+import { detectNamespaceFromPath } from '../namespace-detector.js';
+import { promptText } from '../prompts.js';
+
+export async function uploadAction(filePath, opts) {
+  if (!filePath) {
+    filePath = await promptText('File path: ');
+    if (!filePath) return;
+  }
+
+  const apiKey = requireApiKey();
+
+  if (!opts.source) {
+    console.error('Error: --source is required (source language code, e.g. en)');
+    process.exit(1);
+  }
+  if (!opts.target) {
+    console.error('Error: --target is required (target language code, e.g. es)');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(filePath)) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  let namespace = opts.namespace;
+  if (!namespace) {
+    const config = loadConfig(getConfigPath());
+    namespace = config.defaultNamespace;
+  }
+  if (!namespace) {
+    const detection = detectNamespaceFromPath(path.resolve(filePath));
+    if (detection.suggestion && detection.confidence > 0.5) {
+      namespace = detection.suggestion;
+      printErr(`Auto-detected namespace: "${namespace}"`);
+    }
+  }
+  if (!namespace) {
+    namespace = await promptText('Namespace: ');
+    if (!namespace) {
+      console.error('Error: namespace is required');
+      process.exit(1);
+    }
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const fileName = path.basename(filePath);
+
+  try {
+    printErr(`Uploading ${fileName}...`);
+
+    const result = await uploadFile(
+      `/namespaces/${namespace}/translations/upload`,
+      { sourceLocale: opts.source, targetLocale: opts.target },
+      { name: 'file', content, fileName },
+      apiKey,
+    );
+
+    print(formatOutput(result, {
+      json: opts.json,
+      template: (data) => {
+        const lines = ['Upload successful\n'];
+        lines.push(`  Namespace:  ${namespace}`);
+        lines.push(`  File:       ${fileName}`);
+        lines.push(`  Languages:  ${opts.source} -> ${opts.target}`);
+        if (data.pairsStored) lines.push(`  Pairs stored:  ${data.pairsStored}`);
+        if (data.pairsUpdated) lines.push(`  Pairs updated: ${data.pairsUpdated}`);
+        return lines.join('\n');
+      }
+    }));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function uploadsListAction(opts) {
+  const apiKey = requireApiKey();
+
+  if (!opts.namespace) {
+    console.error('Error: --namespace is required');
+    process.exit(1);
+  }
+
+  try {
+    const args = { namespace: opts.namespace };
+    if (opts.source) args.sourceLocale = opts.source;
+    if (opts.target) args.targetLocale = opts.target;
+
+    const result = await callTool('list_uploaded_translations', args, apiKey);
+
+    print(formatOutput(result, {
+      json: opts.json,
+      template: (data) => {
+        const files = data.files || data.translations || data;
+        if (!Array.isArray(files) || files.length === 0) {
+          return `No uploaded translations found in namespace "${opts.namespace}"`;
+        }
+        const lines = [`Uploaded translations in "${opts.namespace}":\n`];
+        for (const f of files) {
+          lines.push(`  ${f.fileName || f.name} | ${f.sourceLocale} -> ${f.targetLocale} | ${f.translationCount || f.pairs || '?'} pairs`);
+        }
+        return lines.join('\n');
+      }
+    }));
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}

package/src/config.js

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export function getConfigPath() {
+  return path.join(os.homedir(), '.config', 'i18nagent', 'config.json');
+}
+
+export function loadConfig(configPath) {
+  try {
+    if (!fs.existsSync(configPath)) return {};
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(configPath, updates) {
+  const existing = loadConfig(configPath);
+  const merged = { ...existing, ...updates };
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2) + '\n', { mode: 0o600 });
+  return merged;
+}
+
+export function getApiKey(configPath) {
+  if (process.env.I18N_AGENT_API_KEY) {
+    return process.env.I18N_AGENT_API_KEY;
+  }
+  const config = loadConfig(configPath || getConfigPath());
+  return config.apiKey || null;
+}
+
+export function requireApiKey(configPath) {
+  const key = getApiKey(configPath);
+  if (!key) {
+    console.error('Error: No API key found.\n');
+    console.error('Set your API key using one of:');
+    console.error('  i18nagent login');
+    console.error('  export I18N_AGENT_API_KEY=your-key-here\n');
+    console.error('Get your API key at: https://app.i18nagent.ai');
+    process.exit(1);
+  }
+  return key;
+}