@llm-translate/cli 1.0.0-next.1

package/src/cli/commands/file.ts

@@ -0,0 +1,291 @@
+import { Command } from 'commander';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve, dirname, basename, extname } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import type { FileCommandOptions } from '../options.js';
+import { defaults } from '../options.js';
+import { loadConfig, mergeConfig } from '../../services/config.js';
+import { createTranslationEngine } from '../../core/engine.js';
+import { logger, configureLogger } from '../../utils/logger.js';
+import { TranslationError, getExitCode } from '../../errors.js';
+import type { DocumentFormat } from '../../types/index.js';
+
+export const fileCommand = new Command('file')
+  .description('Translate a single file')
+  .argument('<input>', 'Input file path')
+  .argument('[output]', 'Output file path (optional)')
+  .option('-s, --source-lang <lang>', 'Source language code')
+  .option('-t, --target-lang <lang>', 'Target language code')
+  .option('-g, --glossary <path>', 'Path to glossary file')
+  .option(
+    '-p, --provider <name>',
+    'LLM provider (claude|openai|ollama)',
+    defaults.provider
+  )
+  .option('-m, --model <name>', 'Model name')
+  .option(
+    '--quality <0-100>',
+    'Quality threshold',
+    String(defaults.quality)
+  )
+  .option(
+    '--max-iterations <n>',
+    'Max refinement iterations',
+    String(defaults.maxIterations)
+  )
+  .option('-o, --output <path>', 'Output path')
+  .option('-f, --format <fmt>', 'Force output format (md|html|txt)')
+  .option('--dry-run', 'Show what would be translated')
+  .option('--json', 'Output results as JSON')
+  .option(
+    '--chunk-size <tokens>',
+    'Max tokens per chunk',
+    String(defaults.chunkSize)
+  )
+  .option('--no-cache', 'Disable translation cache')
+  .option('--context <text>', 'Additional context for translation')
+  .option('--strict-quality', 'Fail if quality threshold is not met')
+  .option('--strict-glossary', 'Fail if glossary terms are not applied')
+  .option('-v, --verbose', 'Enable verbose logging')
+  .option('-q, --quiet', 'Suppress non-error output')
+  .action(async (input: string, output: string | undefined, options: FileCommandOptions) => {
+    try {
+      // Configure logger
+      configureLogger({
+        level: options.verbose ? 'debug' : 'info',
+        quiet: options.quiet ?? false,
+        json: options.json ?? false,
+      });
+
+      // Validate required options
+      if (!options.sourceLang) {
+        console.error('Error: Source language (-s, --source-lang) is required');
+        process.exit(2);
+      }
+
+      if (!options.targetLang) {
+        console.error('Error: Target language (-t, --target-lang) is required');
+        process.exit(2);
+      }
+
+      // Load configuration
+      const baseConfig = await loadConfig({ configPath: options.config });
+      const config = mergeConfig(baseConfig, {
+        sourceLang: options.sourceLang,
+        targetLang: options.targetLang,
+        provider: options.provider,
+        model: options.model,
+        quality: options.quality ? parseInt(options.quality, 10) : undefined,
+        maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : undefined,
+        chunkSize: options.chunkSize ? parseInt(options.chunkSize, 10) : undefined,
+        glossary: options.glossary,
+        noCache: options.cache === false,
+      });
+
+      // Read input file
+      const inputPath = resolve(input);
+      let content: string;
+
+      try {
+        content = await readFile(inputPath, 'utf-8');
+      } catch (error) {
+        console.error(`Error: Could not read file '${inputPath}'`);
+        process.exit(3);
+      }
+
+      if (!options.quiet) {
+        logger.info(`Reading: ${inputPath}`);
+        logger.info(`Translating: ${options.sourceLang} → ${options.targetLang}`);
+        if (options.glossary) {
+          logger.info(`Glossary: ${resolve(options.glossary)}`);
+        }
+      }
+
+      // Dry run - just show what would be done
+      if (options.dryRun) {
+        console.log('Dry run mode - no translation will be performed');
+        console.log(`Input: ${inputPath}`);
+        console.log(`Output: ${output ?? determineOutputPath(inputPath, options.targetLang)}`);
+        console.log(`Source language: ${options.sourceLang}`);
+        console.log(`Target language: ${options.targetLang}`);
+        console.log(`Content length: ${content.length} characters`);
+        return;
+      }
+
+      // Create translation engine
+      const engine = createTranslationEngine({
+        config,
+        verbose: options.verbose,
+        noCache: options.cache === false,
+      });
+
+      // Translate content
+      const result = await engine.translateContent({
+        content,
+        sourceLang: options.sourceLang,
+        targetLang: options.targetLang,
+        format: mapFormat(options.format),
+        glossaryPath: options.glossary,
+        qualityThreshold: options.quality ? parseInt(options.quality, 10) : undefined,
+        maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : undefined,
+        context: options.context,
+        strictQuality: options.strictQuality,
+        strictGlossary: options.strictGlossary,
+      });
+
+      // Determine output path
+      const outputPath = output ?? options.output ?? determineOutputPath(inputPath, options.targetLang);
+
+      // Ensure output directory exists
+      await mkdir(dirname(outputPath), { recursive: true });
+
+      // Write output
+      await writeFile(outputPath, result.content, 'utf-8');
+
+      // Output results
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: true,
+          input: inputPath,
+          output: outputPath,
+          sourceLang: options.sourceLang,
+          targetLang: options.targetLang,
+          quality: result.metadata.averageQuality,
+          duration: result.metadata.totalDuration,
+          chunks: result.chunks.length,
+          provider: result.metadata.provider,
+          model: result.metadata.model,
+          iterations: result.metadata.totalIterations,
+          tokensUsed: result.metadata.tokensUsed,
+        }, null, 2));
+      } else if (!options.quiet) {
+        logger.success(`Written to ${outputPath}`);
+        console.log('');
+        console.log('  Translation Summary:');
+        console.log(`  - Model: ${result.metadata.provider}/${result.metadata.model}`);
+        console.log(`  - Quality: ${result.metadata.averageQuality.toFixed(0)}/100`);
+        console.log(`  - Chunks: ${result.chunks.length}`);
+        console.log(`  - Iterations: ${result.metadata.totalIterations}`);
+        console.log(`  - Tokens: ${result.metadata.tokensUsed.input.toLocaleString()} input / ${result.metadata.tokensUsed.output.toLocaleString()} output`);
+        console.log(`  - Duration: ${(result.metadata.totalDuration / 1000).toFixed(1)}s`);
+      }
+
+    } catch (error) {
+      if (error instanceof TranslationError) {
+        console.error(`Error: ${error.message}`);
+        process.exit(getExitCode(error));
+      }
+      console.error('Error:', error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Handle stdin/stdout translation mode
+ */
+export async function handleStdinTranslation(
+  options: FileCommandOptions
+): Promise<void> {
+  try {
+    // Configure logger for quiet mode (stdout is for translation output)
+    configureLogger({
+      level: 'error',
+      quiet: true,
+      json: false,
+    });
+
+    // Validate required options
+    if (!options.sourceLang) {
+      console.error('Error: Source language (-s, --source-lang) is required');
+      process.exit(2);
+    }
+
+    if (!options.targetLang) {
+      console.error('Error: Target language (-t, --target-lang) is required');
+      process.exit(2);
+    }
+
+    // Read from stdin
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk as Buffer);
+    }
+    const content = Buffer.concat(chunks).toString('utf-8');
+
+    if (!content.trim()) {
+      console.error('Error: No input provided');
+      process.exit(2);
+    }
+
+    // Load configuration
+    const baseConfig = await loadConfig({ configPath: options.config });
+    const config = mergeConfig(baseConfig, {
+      sourceLang: options.sourceLang,
+      targetLang: options.targetLang,
+      provider: options.provider,
+      model: options.model,
+      quality: options.quality ? parseInt(options.quality, 10) : undefined,
+      maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : undefined,
+      glossary: options.glossary,
+    });
+
+    // Create translation engine
+    const engine = createTranslationEngine({
+      config,
+      verbose: false,
+      noCache: options.cache === false,
+    });
+
+    // Translate content
+    const result = await engine.translateContent({
+      content,
+      sourceLang: options.sourceLang,
+      targetLang: options.targetLang,
+      format: mapFormat(options.format),
+      glossaryPath: options.glossary,
+      qualityThreshold: options.quality ? parseInt(options.quality, 10) : undefined,
+      maxIterations: options.maxIterations ? parseInt(options.maxIterations, 10) : undefined,
+      context: options.context,
+    });
+
+    // Output to stdout
+    process.stdout.write(result.content);
+
+  } catch (error) {
+    if (error instanceof TranslationError) {
+      console.error(`Error: ${error.message}`);
+      process.exit(getExitCode(error));
+    }
+    console.error('Error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function determineOutputPath(inputPath: string, targetLang: string): string {
+  const dir = dirname(inputPath);
+  const ext = extname(inputPath);
+  const base = basename(inputPath, ext);
+
+  return resolve(dir, `${base}.${targetLang}${ext}`);
+}
+
+function mapFormat(format: string | undefined): DocumentFormat | undefined {
+  if (!format) return undefined;
+
+  switch (format.toLowerCase()) {
+    case 'md':
+    case 'markdown':
+      return 'markdown';
+    case 'html':
+      return 'html';
+    case 'txt':
+    case 'text':
+      return 'text';
+    default:
+      return undefined;
+  }
+}

package/src/cli/commands/glossary.ts

@@ -0,0 +1,221 @@
+import { Command } from 'commander';
+import { readFile, writeFile } from 'node:fs/promises';
+import type { Glossary, GlossaryTerm } from '../../types/index.js';
+
+export const glossaryCommand = new Command('glossary')
+  .description('Manage glossary (add, remove, list, validate)');
+
+// ============================================================================
+// Subcommands
+// ============================================================================
+
+glossaryCommand
+  .command('list')
+  .description('List all terms in a glossary')
+  .argument('<path>', 'Path to glossary file')
+  .option('--lang <lang>', 'Filter by target language')
+  .action(async (path: string, options: { lang?: string }) => {
+    try {
+      const glossary = await loadGlossary(path);
+      console.log(`Glossary: ${glossary.metadata.name}`);
+      console.log(`Source: ${glossary.metadata.sourceLang}`);
+      console.log(`Targets: ${glossary.metadata.targetLangs.join(', ')}`);
+      console.log(`Terms: ${glossary.terms.length}`);
+      console.log('---');
+
+      for (const term of glossary.terms) {
+        if (term.doNotTranslate) {
+          console.log(`  ${term.source} → [do not translate]`);
+        } else if (options.lang && term.targets[options.lang]) {
+          console.log(`  ${term.source} → ${term.targets[options.lang]}`);
+        } else if (!options.lang) {
+          const translations = Object.entries(term.targets)
+            .map(([lang, val]) => `${lang}: ${val}`)
+            .join(', ');
+          console.log(`  ${term.source} → ${translations || '[no translations]'}`);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to load glossary:', error);
+      process.exit(1);
+    }
+  });
+
+glossaryCommand
+  .command('validate')
+  .description('Validate a glossary file')
+  .argument('<path>', 'Path to glossary file')
+  .action(async (path: string) => {
+    try {
+      const glossary = await loadGlossary(path);
+      const errors = validateGlossary(glossary);
+
+      if (errors.length === 0) {
+        console.log('Glossary is valid!');
+        console.log(`  Name: ${glossary.metadata.name}`);
+        console.log(`  Terms: ${glossary.terms.length}`);
+        console.log(`  Source: ${glossary.metadata.sourceLang}`);
+        console.log(`  Targets: ${glossary.metadata.targetLangs.join(', ')}`);
+      } else {
+        console.error('Glossary validation failed:');
+        for (const error of errors) {
+          console.error(`  - ${error}`);
+        }
+        process.exit(6); // GLOSSARY_VALIDATION_FAILED
+      }
+    } catch (error) {
+      console.error('Failed to load glossary:', error);
+      process.exit(1);
+    }
+  });
+
+glossaryCommand
+  .command('add')
+  .description('Add a term to the glossary')
+  .argument('<path>', 'Path to glossary file')
+  .argument('<source>', 'Source term')
+  .option('--target <lang:value...>', 'Target translations (e.g., ko:번역)')
+  .option('--context <text>', 'Usage context')
+  .option('--do-not-translate', 'Mark as do not translate')
+  .action(
+    async (
+      path: string,
+      source: string,
+      options: {
+        target?: string[];
+        context?: string;
+        doNotTranslate?: boolean;
+      }
+    ) => {
+      try {
+        const glossary = await loadGlossary(path);
+
+        // Check if term already exists
+        const existing = glossary.terms.find(
+          (t) => t.source.toLowerCase() === source.toLowerCase()
+        );
+        if (existing) {
+          console.error(`Term "${source}" already exists in glossary.`);
+          process.exit(1);
+        }
+
+        // Parse targets
+        const targets: Record<string, string> = {};
+        if (options.target) {
+          for (const t of options.target) {
+            const [lang, ...rest] = t.split(':');
+            if (lang && rest.length > 0) {
+              targets[lang] = rest.join(':');
+            }
+          }
+        }
+
+        const newTerm: GlossaryTerm = {
+          source,
+          targets,
+          context: options.context,
+          doNotTranslate: options.doNotTranslate,
+        };
+
+        glossary.terms.push(newTerm);
+        await writeFile(path, JSON.stringify(glossary, null, 2));
+        console.log(`Added term: ${source}`);
+      } catch (error) {
+        console.error('Failed to add term:', error);
+        process.exit(1);
+      }
+    }
+  );
+
+glossaryCommand
+  .command('remove')
+  .description('Remove a term from the glossary')
+  .argument('<path>', 'Path to glossary file')
+  .argument('<source>', 'Source term to remove')
+  .action(async (path: string, source: string) => {
+    try {
+      const glossary = await loadGlossary(path);
+      const index = glossary.terms.findIndex(
+        (t) => t.source.toLowerCase() === source.toLowerCase()
+      );
+
+      if (index === -1) {
+        console.error(`Term "${source}" not found in glossary.`);
+        process.exit(1);
+      }
+
+      glossary.terms.splice(index, 1);
+      await writeFile(path, JSON.stringify(glossary, null, 2));
+      console.log(`Removed term: ${source}`);
+    } catch (error) {
+      console.error('Failed to remove term:', error);
+      process.exit(1);
+    }
+  });
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+async function loadGlossary(path: string): Promise<Glossary> {
+  const content = await readFile(path, 'utf-8');
+  return JSON.parse(content) as Glossary;
+}
+
+function validateGlossary(glossary: Glossary): string[] {
+  const errors: string[] = [];
+
+  // Check metadata
+  if (!glossary.metadata) {
+    errors.push('Missing metadata section');
+  } else {
+    if (!glossary.metadata.name) {
+      errors.push('Missing metadata.name');
+    }
+    if (!glossary.metadata.sourceLang) {
+      errors.push('Missing metadata.sourceLang');
+    }
+    if (
+      !glossary.metadata.targetLangs ||
+      glossary.metadata.targetLangs.length === 0
+    ) {
+      errors.push('Missing or empty metadata.targetLangs');
+    }
+  }
+
+  // Check terms
+  if (!glossary.terms || !Array.isArray(glossary.terms)) {
+    errors.push('Missing or invalid terms array');
+  } else {
+    const seenSources = new Set<string>();
+
+    for (let i = 0; i < glossary.terms.length; i++) {
+      const term = glossary.terms[i];
+      if (!term) continue;
+
+      if (!term.source) {
+        errors.push(`Term at index ${i}: missing source`);
+        continue;
+      }
+
+      // Check for duplicates
+      const normalizedSource = term.source.toLowerCase();
+      if (seenSources.has(normalizedSource)) {
+        errors.push(`Duplicate term: "${term.source}"`);
+      }
+      seenSources.add(normalizedSource);
+
+      // Check targets if not doNotTranslate
+      if (!term.doNotTranslate && Object.keys(term.targets).length === 0) {
+        // This is a warning, not an error - term might have doNotTranslateFor
+        if (!term.doNotTranslateFor || term.doNotTranslateFor.length === 0) {
+          errors.push(
+            `Term "${term.source}": no translations and not marked as do-not-translate`
+          );
+        }
+      }
+    }
+  }
+
+  return errors;
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import { writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { TranslateConfig } from '../../types/index.js';
+
+const defaultConfig: TranslateConfig = {
+  version: '1.0',
+  project: {
+    name: 'My Project',
+    description: 'Project description',
+    purpose: 'Technical documentation translation',
+  },
+  languages: {
+    source: 'en',
+    targets: ['ko'],
+  },
+  provider: {
+    default: 'claude',
+    model: 'claude-sonnet-4-20250514',
+  },
+  quality: {
+    threshold: 85,
+    maxIterations: 4,
+    evaluationMethod: 'llm',
+  },
+  chunking: {
+    maxTokens: 1024,
+    overlapTokens: 150,
+    preserveStructure: true,
+  },
+  paths: {
+    output: './docs/{lang}',
+    cache: './.translate-cache',
+  },
+  ignore: ['**/node_modules/**', '**/*.test.md'],
+};
+
+export const initCommand = new Command('init')
+  .description('Initialize project configuration')
+  .option('-f, --force', 'Overwrite existing configuration')
+  .action(async (options: { force?: boolean }) => {
+    const configPath = join(process.cwd(), '.translaterc.json');
+
+    // Check if config already exists
+    if (!options.force) {
+      try {
+        await access(configPath);
+        console.error(
+          'Configuration file already exists. Use --force to overwrite.'
+        );
+        process.exit(1);
+      } catch {
+        // File doesn't exist, continue
+      }
+    }
+
+    try {
+      await writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
+      console.log('Created .translaterc.json');
+      console.log('\nNext steps:');
+      console.log('1. Edit .translaterc.json to configure your project');
+      console.log('2. Set your API key: export ANTHROPIC_API_KEY=your-key');
+      console.log('3. Run: llm-translate file <input> -s en -t ko');
+    } catch (error) {
+      console.error('Failed to create configuration file:', error);
+      process.exit(1);
+    }
+  });

package/src/cli/commands/serve.ts

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import { startServer } from '../../server/index.js';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface ServeCommandOptions {
+  port?: string;
+  host?: string;
+  auth?: boolean; // Commander's --no-auth sets this to false
+  cors?: boolean;
+  json?: boolean;
+}
+
+// ============================================================================
+// Serve Command
+// ============================================================================
+
+export const serveCommand = new Command('serve')
+  .description('Start the translation API server')
+  .option(
+    '-p, --port <number>',
+    'Server port (env: TRANSLATE_PORT)',
+    process.env['TRANSLATE_PORT'] ?? '3000'
+  )
+  .option('-H, --host <string>', 'Host to bind', '0.0.0.0')
+  .option('--no-auth', 'Disable API key authentication')
+  .option('--cors', 'Enable CORS for browser clients')
+  .option('--json', 'Use JSON logging format (for containers)')
+  .action((options: ServeCommandOptions) => {
+    const port = parseInt(options.port ?? '3000', 10);
+    const host = options.host ?? '0.0.0.0';
+
+    // Validate port
+    if (isNaN(port) || port < 1 || port > 65535) {
+      console.error('Error: Invalid port number. Must be between 1 and 65535.');
+      process.exit(2);
+    }
+
+    // Check for API key if auth is enabled
+    const enableAuth = options.auth !== false;
+    if (enableAuth && !process.env['TRANSLATE_API_KEY']) {
+      console.warn(
+        'Warning: TRANSLATE_API_KEY not set. API key authentication is disabled.'
+      );
+      console.warn(
+        'Set TRANSLATE_API_KEY environment variable to enable authentication.\n'
+      );
+    }
+
+    startServer({
+      port,
+      host,
+      enableAuth,
+      enableCors: options.cors ?? false,
+      apiKey: process.env['TRANSLATE_API_KEY'],
+      jsonLogging: options.json ?? false,
+    });
+  });