@localheroai/cli 0.0.3 → 0.0.6

package/src/utils/files.js

@@ -1,361 +0,0 @@
-import chalk from 'chalk';
-import { glob } from 'glob';
-import { readFile } from 'fs/promises';
-import path from 'path';
-import yaml from 'yaml';
-import { promises as fs } from 'fs';
-
-export function parseFile(content, format) {
-  try {
-    if (format === 'json') {
-      return JSON.parse(content);
-    }
-    return yaml.parse(content);
-  } catch (error) {
-    throw new Error(`Failed to parse ${format} file: ${error.message}`);
-  }
-}
-
-export function extractLocaleFromPath(filePath, localeRegex, knownLocales = []) {
-  if (knownLocales && knownLocales.length > 0) {
-    const basename = path.basename(filePath, path.extname(filePath));
-    const foundLocaleInFilename = knownLocales.find(locale =>
-      locale && basename.toLowerCase() === locale.toLowerCase()
-    );
-    if (foundLocaleInFilename) {
-      return foundLocaleInFilename.toLowerCase();
-    }
-
-    // Then try to match in the path
-    const pathParts = filePath.toLowerCase().split(path.sep);
-    const foundLocaleInPath = knownLocales.find(locale =>
-      locale && pathParts.includes(locale.toLowerCase())
-    );
-    if (foundLocaleInPath) {
-      return foundLocaleInPath.toLowerCase();
-    }
-  }
-
-  const dirName = path.basename(path.dirname(filePath));
-  if (dirName && isValidLocale(dirName)) {
-    return dirName.toLowerCase();
-  }
-
-  if (localeRegex) {
-    const filename = path.basename(filePath);
-    const regexPattern = new RegExp(localeRegex);
-    const regexMatch = filename.match(regexPattern);
-    if (regexMatch && regexMatch[1]) {
-      const locale = regexMatch[1].toLowerCase();
-      if (isValidLocale(locale)) {
-        return locale;
-      }
-    }
-  }
-
-  throw new Error(`Could not extract locale from path: ${filePath}`);
-}
-
-export function isValidLocale(locale) {
-  // Basic validation for language code (2 letters) or language-region code (e.g., en-US)
-  return /^[a-z]{2}(?:-[A-Z]{2})?$/.test(locale);
-}
-
-export function flattenTranslations(obj, parentKey = '') {
-  const result = {};
-
-  for (const [key, value] of Object.entries(obj)) {
-    const newKey = parentKey ? `${parentKey}.${key}` : key;
-
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-      Object.assign(result, flattenTranslations(value, newKey));
-    } else {
-      result[newKey] = value;
-    }
-  }
-
-  return result;
-}
-
-function detectJsonFormat(obj) {
-  let hasNested = false;
-  let hasDotNotation = false;
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (key.includes('.')) {
-      hasDotNotation = true;
-    }
-
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
-      hasNested = true;
-
-      for (const [, nestedValue] of Object.entries(value)) {
-        if (nestedValue && typeof nestedValue === 'object' && !Array.isArray(nestedValue)) {
-          return 'nested';
-        }
-      }
-    }
-  }
-
-  if (hasNested && hasDotNotation) {
-    return 'mixed';
-  } else if (hasNested) {
-    return 'nested';
-  } else if (hasDotNotation) {
-    return 'flat';
-  }
-
-  return 'flat';
-}
-
-function unflattenTranslations(flatObj) {
-  const result = {};
-
-  for (const [key, value] of Object.entries(flatObj)) {
-    const keys = key.split('.');
-    let current = result;
-
-    for (let i = 0; i < keys.length - 1; i++) {
-      const k = keys[i];
-      current[k] = current[k] || {};
-      current = current[k];
-    }
-
-    current[keys[keys.length - 1]] = value;
-  }
-
-  return result;
-}
-
-function preserveJsonStructure(originalObj, newTranslations, format) {
-  if (format === 'flat') {
-    return { ...originalObj, ...newTranslations };
-  }
-
-  if (format === 'nested') {
-    const merged = { ...originalObj };
-    const unflattenedNew = unflattenTranslations(newTranslations);
-    return deepMerge(merged, unflattenedNew);
-  }
-  const result = { ...originalObj };
-
-  for (const [key, value] of Object.entries(newTranslations)) {
-    if (key.includes('.')) {
-      const keys = key.split('.');
-      if (originalObj[key] !== undefined) {
-        result[key] = value;
-        continue;
-      }
-
-      let current = result;
-
-      for (let i = 0; i < keys.length - 1; i++) {
-        const k = keys[i];
-        current[k] = current[k] || {};
-        if (typeof current[k] !== 'object' || Array.isArray(current[k])) {
-          current[k] = {};
-        }
-
-        current = current[k];
-      }
-
-      current[keys[keys.length - 1]] = value;
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
-}
-
-function deepMerge(target, source) {
-  const result = { ...target };
-
-  for (const [key, value] of Object.entries(source)) {
-    if (value && typeof value === 'object' &&
-      result[key] && typeof result[key] === 'object' &&
-      !Array.isArray(value) && !Array.isArray(result[key])) {
-      result[key] = deepMerge(result[key], value);
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
-}
-
-function extractNamespace(filePath) {
-  const fileName = path.basename(filePath, path.extname(filePath));
-  const dirName = path.basename(path.dirname(filePath));
-
-  // Pattern 1: /path/to/en/common.json -> namespace = common
-  if (/^[a-z]{2}(-[A-Z]{2})?$/.test(dirName)) {
-    return fileName;
-  }
-
-  // Pattern 2: /path/to/messages.en.json -> namespace = messages
-  const dotMatch = fileName.match(/^(.+)\.([a-z]{2}(?:-[A-Z]{2})?)$/);
-  if (dotMatch) {
-    return dotMatch[1];
-  }
-
-  // Pattern 3: /path/to/common-en.json -> namespace = common
-  const dashMatch = fileName.match(/^(.+)-([a-z]{2}(?:-[A-Z]{2})?)$/);
-  if (dashMatch) {
-    return dashMatch[1];
-  }
-
-  return '';
-}
-
-export async function findTranslationFiles(config, options = {}) {
-  const {
-    parseContent = true,
-    includeContent = true,
-    extractKeys = true,
-    basePath = process.cwd(),
-    sourceLocale = config.sourceLocale,
-    targetLocales = config.outputLocales || [],
-    includeNamespace = false,
-    verbose = false,
-    returnFullResult = false
-  } = options;
-  const knownLocales = [sourceLocale, ...targetLocales];
-  const { translationFiles } = config;
-  const {
-    paths = [],
-    pattern = '**/*.{json,yml,yaml}',
-    ignore = [],
-    localeRegex = '.*?([a-z]{2}(?:-[A-Z]{2})?)\\.(?:yml|yaml|json)$'
-  } = translationFiles || {};
-
-  const processedFiles = [];
-
-  for (const translationPath of paths) {
-    const fullPath = path.join(basePath, translationPath);
-    const globPattern = path.join(fullPath, pattern);
-
-    if (verbose) {
-      console.log(chalk.blue(`Searching for translation files in ${globPattern}`));
-    }
-
-    let files;
-    try {
-      files = await glob(globPattern, {
-        ignore: ignore.map(i => path.join(basePath, i)),
-        absolute: false
-      });
-
-      if (verbose) {
-        console.log(chalk.blue(`Found ${files.length} files in ${translationPath}`));
-      }
-    } catch (error) {
-      if (verbose) {
-        console.error(chalk.red(`Error searching for files in ${translationPath}: ${error.message}`));
-      }
-      files = [];
-    }
-
-    for (const file of files) {
-      try {
-        const filePath = file;
-        const format = path.extname(file).slice(1);
-        const locale = extractLocaleFromPath(file, localeRegex, knownLocales);
-
-        const result = {
-          path: filePath,
-          format,
-          locale
-        };
-
-        if (parseContent) {
-          const content = await readFile(filePath, 'utf8');
-          const parsedContent = parseFile(content, format);
-
-          if (includeContent) {
-            result.content = Buffer.from(content).toString('base64');
-          }
-
-          if (extractKeys) {
-            const hasLanguageWrapper = parsedContent[locale] !== undefined;
-            result.hasLanguageWrapper = hasLanguageWrapper;
-            const translationData = hasLanguageWrapper ? parsedContent[locale] : parsedContent;
-            result.translations = translationData;
-            result.keys = flattenTranslations(translationData);
-          }
-        }
-
-        if (includeNamespace) {
-          result.namespace = extractNamespace(filePath);
-        }
-
-        processedFiles.push(result);
-      } catch (error) {
-        if (verbose) {
-          console.warn(chalk.yellow(`Warning: ${error.message}`));
-        }
-      }
-    }
-  }
-
-  if (!returnFullResult) {
-    return processedFiles;
-  }
-
-  const allFiles = processedFiles;
-  const sourceFiles = allFiles.filter(file => file.locale === sourceLocale);
-  const targetFilesByLocale = {};
-
-  for (const locale of targetLocales) {
-    targetFilesByLocale[locale] = allFiles.filter(file => file.locale === locale);
-  }
-
-  return {
-    allFiles,
-    sourceFiles,
-    targetFilesByLocale
-  };
-}
-
-export {
-  unflattenTranslations,
-  detectJsonFormat,
-  preserveJsonStructure,
-  directoryExists,
-  findFirstExistingPath,
-  getDirectoryContents
-};
-
-async function directoryExists(path, fsModule = fs) {
-  try {
-    const stats = await fsModule.stat(path);
-    return stats.isDirectory();
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return false;
-    }
-    throw error;
-  }
-}
-
-async function findFirstExistingPath(paths, fsModule = fs) {
-  for (const path of paths) {
-    if (await directoryExists(path, fsModule)) {
-      return path;
-    }
-  }
-  return null;
-}
-
-async function getDirectoryContents(dir, fsModule = fs) {
-  try {
-    const files = await fsModule.readdir(dir);
-    return {
-      files,
-      jsonFiles: files.filter(f => f.endsWith('.json')),
-      yamlFiles: files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'))
-    };
-  } catch {
-    return null;
-  }
-}

package/src/utils/git.js

@@ -1,72 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { promisify } from 'util';
-import { execFile } from 'child_process';
-
-const execFileAsync = promisify(execFile);
-
-const defaultDeps = {
-  fs,
-  path,
-  exec: execFileAsync,
-};
-
-export const gitService = {
-  deps: { ...defaultDeps },
-
-  setDependencies(customDeps = {}) {
-    this.deps = { ...defaultDeps, ...customDeps };
-    return this;
-  },
-
-  async updateGitignore(basePath) {
-    const { fs, path } = this.deps;
-    const gitignorePath = path.join(basePath, '.gitignore');
-    let content = '';
-
-    try {
-      content = await fs.readFile(gitignorePath, 'utf8');
-    } catch (error) {
-      if (error.code !== 'ENOENT') {
-        return false;
-      }
-    }
-
-    if (content.includes('.localhero_key')) {
-      return false;
-    }
-
-    try {
-      await fs.appendFile(gitignorePath, '\n.localhero_key\n');
-      return true;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        try {
-          await fs.writeFile(gitignorePath, '.localhero_key\n');
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      return false;
-    }
-  },
-
-  async getCurrentBranch() {
-    try {
-      const { exec } = this.deps;
-      const { stdout } = await exec('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
-      return stdout.trim();
-    } catch {
-      return null;
-    }
-  }
-};
-
-export async function updateGitignore(basePath) {
-  return gitService.updateGitignore(basePath);
-}
-
-export async function getCurrentBranch() {
-  return gitService.getCurrentBranch();
-}

package/src/utils/github.js

@@ -1,122 +0,0 @@
-import { execSync } from 'child_process';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-const defaultDependencies = {
-  exec: (cmd, options) => execSync(cmd, options),
-  fs,
-  path,
-  env: process.env
-};
-
-export const githubService = {
-  deps: { ...defaultDependencies },
-
-  // For testing - reset or inject custom dependencies
-  setDependencies(customDeps = {}) {
-    this.deps = { ...defaultDependencies, ...customDeps };
-    return this;
-  },
-
-  isGitHubAction() {
-    return this.deps.env.GITHUB_ACTIONS === 'true';
-  },
-
-  async createGitHubActionFile(basePath, translationPaths) {
-    const { fs, path } = this.deps;
-    const workflowDir = path.join(basePath, '.github', 'workflows');
-    const workflowFile = path.join(workflowDir, 'localhero-translate.yml');
-
-    await fs.mkdir(workflowDir, { recursive: true });
-
-    const actionContent = `name: Localhero.ai - I18n translation
-
-on:
-  pull_request:
-    paths:
-      ${translationPaths.map(p => `- "${p}"`).join('\n      ')}
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-      with:
-        ref: \${{ github.head_ref }}
-        fetch-depth: 0
-
-    - name: Set up Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: 18
-
-    - name: Run LocalHero CLI
-      env:
-        LOCALHERO_API_KEY: \${{ secrets.LOCALHERO_API_KEY }}
-        GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-      run: npx -y @localheroai/cli translate`;
-
-    await fs.writeFile(workflowFile, actionContent);
-    return workflowFile;
-  },
-
-  autoCommitChanges(filesPath) {
-    const { exec, env } = this.deps;
-
-    if (!this.isGitHubAction()) return;
-
-    console.log("Running in GitHub Actions. Committing changes...");
-    try {
-      exec('git config --global user.name "LocalHero Bot"', { stdio: "inherit" });
-      exec('git config --global user.email "hi@localhero.ai"', { stdio: "inherit" });
-
-      const branchName = env.GITHUB_HEAD_REF;
-      if (!branchName) {
-        throw new Error('Could not determine branch name from GITHUB_HEAD_REF');
-      }
-
-      exec(`git add ${filesPath}`, { stdio: "inherit" });
-
-      const status = exec('git status --porcelain').toString();
-      if (!status) {
-        console.log("No changes to commit.");
-        return;
-      }
-
-      exec('git commit -m "Update translations"', { stdio: "inherit" });
-
-      const token = env.GITHUB_TOKEN;
-      if (!token) {
-        throw new Error('GITHUB_TOKEN is not set');
-      }
-
-      const repository = env.GITHUB_REPOSITORY;
-      if (!repository) {
-        throw new Error('GITHUB_REPOSITORY is not set');
-      }
-
-      const remoteUrl = `https://x-access-token:${token}@github.com/${repository}.git`;
-
-      exec(`git remote set-url origin ${remoteUrl}`, { stdio: "inherit" });
-      exec(`git push origin HEAD:${branchName}`, { stdio: "inherit" });
-      console.log("Changes committed and pushed successfully.");
-    } catch (error) {
-      console.error("Auto-commit failed:", error.message);
-      throw error;
-    }
-  }
-};
-
-// Only export the functions needed externally
-export function createGitHubActionFile(basePath, translationPaths) {
-  return githubService.createGitHubActionFile(basePath, translationPaths);
-}
-
-export function autoCommitChanges(filesPath) {
-  return githubService.autoCommitChanges(filesPath);
-}

package/src/utils/import-service.js

@@ -1,129 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import { createImport, checkImportStatus } from '../api/imports.js';
-import { findTranslationFiles, flattenTranslations } from './files.js';
-
-function getFileFormat(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  if (ext === '.json') return 'json';
-  if (ext === '.yml' || ext === '.yaml') return 'yaml';
-  return null;
-}
-
-async function readFileContent(filePath) {
-  const content = await fs.readFile(filePath, 'utf8');
-  const format = getFileFormat(filePath);
-
-  if (format === 'json') {
-    try {
-      const jsonContent = JSON.parse(content);
-      const flattened = flattenTranslations(jsonContent);
-
-      return Buffer.from(JSON.stringify(flattened)).toString('base64');
-    } catch {
-      return Buffer.from(content).toString('base64');
-    }
-  }
-
-  return Buffer.from(content).toString('base64');
-}
-
-export const importService = {
-  async findTranslationFiles(config, basePath = process.cwd()) {
-    const files = await findTranslationFiles(config, {
-      basePath,
-      parseContent: false,
-      includeContent: false,
-      extractKeys: false,
-      includeNamespace: true
-    });
-
-    return files.map(file => ({
-      path: path.isAbsolute(file.path) ? path.relative(basePath, file.path) : file.path,
-      language: file.locale,
-      format: file.format === 'yml' ? 'yaml' : file.format,
-      namespace: file.namespace || ''
-    }));
-  },
-
-  async importTranslations(config, basePath = process.cwd()) {
-    const files = await this.findTranslationFiles(config, basePath);
-
-    if (!files.length) {
-      return { status: 'no_files' };
-    }
-
-    const sourceFiles = files.filter(file => file.language === config.sourceLocale);
-    const targetFiles = files.filter(file => file.language !== config.sourceLocale);
-    const importedFiles = {
-      source: sourceFiles,
-      target: targetFiles
-    };
-
-    if (!sourceFiles.length) {
-      return {
-        status: 'failed',
-        error: 'No source language files found. Source language files must be included in the first import.',
-        files: importedFiles
-      };
-    }
-
-    const allTranslations = [];
-
-    for (const file of sourceFiles) {
-      const fullPath = path.join(basePath, file.path);
-      allTranslations.push({
-        language: file.language,
-        format: file.format === 'yml' ? 'yaml' : file.format,
-        filename: file.path,
-        content: await readFileContent(fullPath)
-      });
-    }
-
-    for (const file of targetFiles) {
-      const fullPath = path.join(basePath, file.path);
-      allTranslations.push({
-        language: file.language,
-        format: file.format === 'yml' ? 'yaml' : file.format,
-        filename: file.path,
-        content: await readFileContent(fullPath)
-      });
-    }
-
-    const importResult = await createImport({
-      projectId: config.projectId,
-      translations: allTranslations
-    });
-
-    if (importResult.status === 'failed') {
-      return {
-        ...importResult,
-        files: importedFiles
-      };
-    }
-
-    let finalImportResult = importResult;
-    while (finalImportResult.status === 'processing') {
-      await new Promise(resolve => setTimeout(resolve, finalImportResult.poll_interval * 1000));
-      finalImportResult = await checkImportStatus(config.projectId, finalImportResult.id);
-
-      if (finalImportResult.status === 'failed') {
-        return {
-          ...finalImportResult,
-          files: importedFiles
-        };
-      }
-    }
-
-    // Ensure we pass through all relevant fields from the API response
-    const { status, statistics, warnings, translations_url, sourceImport } = finalImportResult;
-    return {
-      status,
-      statistics,
-      warnings,
-      translations_url,
-      sourceImport,
-      files: importedFiles
-    };
-  }
-};