@localheroai/cli 0.0.1 → 0.0.3

package/src/utils/github.js

@@ -2,15 +2,31 @@ import { execSync } from 'child_process';
 import { promises as fs } from 'fs';
 import path from 'path';
 
-export function isGitHubAction() {
-    return process.env.GITHUB_ACTIONS === 'true';
-}
+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;
+  },
 
-export async function createGitHubActionFile(basePath, translationPaths) {
+  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');
 
-    // Create directories if they don't exist
     await fs.mkdir(workflowDir, { recursive: true });
 
     const actionContent = `name: Localhero.ai - I18n translation
@@ -23,10 +39,16 @@ on:
 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
@@ -36,30 +58,65 @@ jobs:
     - name: Run LocalHero CLI
       env:
         LOCALHERO_API_KEY: \${{ secrets.LOCALHERO_API_KEY }}
-      run: npx @localheroai/cli translate`;
+        GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+      run: npx -y @localheroai/cli translate`;
 
     await fs.writeFile(workflowFile, actionContent);
     return workflowFile;
-}
+  },
 
-export function autoCommitChanges(filesPath) {
-    if (!isGitHubAction()) return;
+  autoCommitChanges(filesPath) {
+    const { exec, env } = this.deps;
+
+    if (!this.isGitHubAction()) return;
 
     console.log("Running in GitHub Actions. Committing changes...");
     try {
-        execSync(`git config --global user.name "LocalHero Bot"`, { stdio: "inherit" });
-        execSync(`git config --global user.email "bot@localhero.ai"`, { stdio: "inherit" });
-        execSync(`git add ${filesPath}`, { stdio: "inherit" });
-        execSync(`git commit -m "Update translations"`, { stdio: "inherit" });
-        const branchName = process.env.GITHUB_HEAD_REF;
-        execSync(`git push origin ${branchName}`, { stdio: "inherit" });
-        console.log("Changes committed and pushed.");
+      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) {
-        if (error.message.includes("nothing to commit")) {
-            console.log("No changes to commit.");
-            return;
-        }
-        console.error("Auto-commit failed:", error.message);
-        throw 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,146 +1,129 @@
 import { promises as fs } from 'fs';
 import path from 'path';
-import { glob } from 'glob';
 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;
+  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');
-    return Buffer.from(content).toString('base64');
-}
+  const content = await fs.readFile(filePath, 'utf8');
+  const format = getFileFormat(filePath);
+
+  if (format === 'json') {
+    try {
+      const jsonContent = JSON.parse(content);
+      const flattened = flattenTranslations(jsonContent);
 
-function getLanguageFromPath(filePath, sourceLocale) {
-    const fileName = path.basename(filePath, path.extname(filePath));
-    return fileName === sourceLocale ? sourceLocale : fileName;
+      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 { translationFiles, sourceLocale } = config;
-        const { paths, ignore = [] } = translationFiles;
-
-        const allFiles = [];
-        for (const translationPath of paths) {
-            const fullPath = path.join(basePath, translationPath);
-            const pattern = path.join(fullPath, '**/*.{json,yml,yaml}');
-
-            const files = await glob(pattern, {
-                ignore: ignore.map(p => path.join(basePath, p)),
-                nodir: true
-            });
-
-            allFiles.push(...files);
-        }
-
-        return allFiles.map(file => ({
-            path: path.relative(basePath, file),
-            language: getLanguageFromPath(file, sourceLocale),
-            format: getFileFormat(file)
-        }));
-    },
-
-    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
-        };
+  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
+      };
+    }
 
-        if (!sourceFiles.length) {
-            return {
-                status: 'failed',
-                error: 'No source language files found. Source language files must be included in the first import.',
-                files: importedFiles
-            };
-        }
-
-        // First import: source language files
-        const sourceTranslations = await Promise.all(
-            sourceFiles.map(async file => ({
-                language: file.language,
-                format: file.format,
-                filename: file.path,
-                content: await readFileContent(path.join(basePath, file.path))
-            }))
-        );
-
-        const sourceImport = await createImport({
-            projectId: config.projectId,
-            translations: sourceTranslations
-        });
-
-        if (sourceImport.status === 'failed') {
-            return sourceImport;
-        }
-
-        let finalSourceImport = sourceImport;
-        while (finalSourceImport.status === 'processing') {
-            await new Promise(resolve => setTimeout(resolve, finalSourceImport.poll_interval * 1000));
-            finalSourceImport = await checkImportStatus(config.projectId, finalSourceImport.id);
-
-            if (finalSourceImport.status === 'failed') {
-                return finalSourceImport;
-            }
-        }
-
-        if (!targetFiles.length) {
-            return { ...finalSourceImport, files: importedFiles };
-        }
-
-        // Second import: target language files
-        const targetTranslations = await Promise.all(
-            targetFiles.map(async file => ({
-                language: file.language,
-                format: file.format,
-                filename: file.path,
-                content: await readFileContent(path.join(basePath, file.path))
-            }))
-        );
-
-        const targetImport = await createImport({
-            projectId: config.projectId,
-            translations: targetTranslations
-        });
-
-        if (targetImport.status === 'completed') {
-            return {
-                ...targetImport,
-                sourceImport: finalSourceImport,
-                files: importedFiles
-            };
-        }
-
-        let finalTargetImport = targetImport;
-        while (finalTargetImport.status === 'processing') {
-            await new Promise(resolve => setTimeout(resolve, finalTargetImport.poll_interval * 1000));
-            finalTargetImport = await checkImportStatus(config.projectId, finalTargetImport.id);
-
-            if (finalTargetImport.status !== 'processing') {
-                return {
-                    ...finalTargetImport,
-                    sourceImport: finalSourceImport,
-                    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 {
-            ...finalTargetImport,
-            sourceImport: finalSourceImport,
-            files: importedFiles
+          ...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
+    };
+  }
+};

package/src/utils/prompt-service.js

@@ -1,51 +1,67 @@
-import path from 'path';
-
 export function createPromptService(deps = {}) {
-    const { inquirer = null } = deps;
-
-    return {
-        async getApiKey() {
-            if (!inquirer) return '';
-            return inquirer.password({
-                message: 'API Key:',
-                mask: '*'
-            });
-        },
-
-        async getProjectSetup() {
-            if (!inquirer) return {};
-
-            return {
-                projectName: '',
-                sourceLocale: '',
-                outputLocales: [],
-                translationPath: '',
-                ignorePaths: []
-            };
-        },
-
-        async confirmLogin() {
-            if (!inquirer) return { shouldLogin: false };
-            const result = await inquirer.confirm({
-                message: 'Would you like to login now?',
-                default: true
-            });
-            return { shouldLogin: result };
-        },
-
-        async select(options) {
-            if (!inquirer) return 'new';
-            return inquirer.select(options);
-        },
-
-        async input(options) {
-            if (!inquirer) return '';
-            return inquirer.input(options);
-        },
-
-        async confirm(options) {
-            if (!inquirer) return false;
-            return inquirer.confirm(options);
-        }
-    };
-} 
+  const { inquirer = null } = deps;
+
+  return {
+    async getApiKey() {
+      if (!inquirer) return '';
+      return inquirer.password({
+        message: 'API Key:',
+        mask: '*'
+      });
+    },
+
+    async getProjectSetup() {
+      if (!inquirer) return {};
+
+      return {
+        projectName: '',
+        sourceLocale: '',
+        outputLocales: [],
+        translationPath: '',
+        ignorePaths: []
+      };
+    },
+
+    async select(options) {
+      if (!inquirer) return 'new';
+      return inquirer.select(options);
+    },
+
+    async input(options) {
+      if (!inquirer) return '';
+      return inquirer.input(options);
+    },
+
+    async confirm(options) {
+      if (!inquirer) return false;
+      return inquirer.confirm(options);
+    },
+
+    async selectProject(projectService) {
+      const projects = await projectService.listProjects();
+
+      if (!projects || projects.length === 0) {
+        return { choice: 'new' };
+      }
+
+      const choices = [
+        { name: '✨ Create new project', value: 'new' },
+        { name: '─────────────', value: 'separator', disabled: true },
+        ...projects.map(p => ({
+          name: p.name,
+          value: p.id
+        }))
+      ];
+
+      const projectChoice = await this.select({
+        message: 'Would you like to use an existing project or create a new one?',
+        choices
+      });
+
+      return {
+        choice: projectChoice,
+        project: projects.find(p => p.id === projectChoice)
+      };
+    }
+  };
+}

package/src/utils/sync-service.js

@@ -0,0 +1,147 @@
+import chalk from 'chalk';
+import { configService } from './config.js';
+import { getUpdates } from '../api/translations.js';
+import { updateTranslationFile, deleteKeysFromTranslationFile } from './translation-updater/index.js';
+import { findTranslationFiles } from './files.js';
+
+const MAX_PAGES = 20;
+
+export const syncService = {
+  async checkForUpdates({ verbose = false } = {}) {
+    const config = await configService.getValidProjectConfig();
+
+    if (!config.projectId) {
+      throw new Error('Project not initialized. Please run `localhero init` first.');
+    }
+
+    const since = config.lastSyncedAt || new Date(0).toISOString();
+
+    if (verbose) {
+      console.log(chalk.blue(`Checking for updates since ${since}`));
+    }
+
+    let allFiles = [];
+    let deletedKeys = [];
+    let currentPage = 1;
+    let hasMorePages = true;
+
+    while (hasMorePages && currentPage <= MAX_PAGES) {
+      const response = await getUpdates(config.projectId, { since, page: currentPage });
+
+      if (response.updates?.updated_keys?.length) {
+        allFiles = allFiles.concat(response.updates.updated_keys);
+      }
+
+      if (response.updates?.deleted_keys?.length) {
+        deletedKeys = deletedKeys.concat(response.updates.deleted_keys);
+      }
+
+      if (response.pagination) {
+        const { current_page, total_pages } = response.pagination;
+        hasMorePages = current_page < total_pages;
+        currentPage++;
+
+        if (verbose && hasMorePages) {
+          if (total_pages > MAX_PAGES) {
+            console.log(chalk.yellow(`  ⚠️  Limiting to ${MAX_PAGES} pages out of ${total_pages} total`));
+          } else {
+            console.log(chalk.gray(`  Fetching page ${currentPage} of ${total_pages}`));
+          }
+        }
+      } else {
+        hasMorePages = false;
+      }
+    }
+
+    if (!allFiles.length && !deletedKeys.length) {
+      if (verbose) {
+        console.log(chalk.green('✓ All translations are up to date'));
+      }
+      return { hasUpdates: false };
+    }
+
+    return {
+      hasUpdates: true,
+      updates: {
+        updates: {
+          files: allFiles,
+          deleted_keys: deletedKeys
+        }
+      }
+    };
+  },
+
+  async applyUpdates(updates, { verbose = false } = {}) {
+    let totalUpdates = 0;
+    let totalDeleted = 0;
+    for (const file of updates.updates.files || []) {
+      for (const lang of file.languages) {
+        if (verbose) {
+          console.log(chalk.blue(`Updating ${lang.code} translations in ${file.path}`));
+        }
+
+        const translations = {};
+        for (const translation of lang.translations) {
+          translations[translation.key] = translation.value;
+          if (verbose) {
+            const displayValue = translation.value.length > 100 ? `${translation.value.slice(0, 100)}…` : translation.value;
+            console.log(chalk.gray(` ${translation.key} = ${displayValue}`));
+          }
+        }
+
+        try {
+          await updateTranslationFile(file.path, translations, lang.code);
+          totalUpdates += Object.keys(translations).length;
+        } catch (error) {
+          console.error(chalk.yellow(`⚠️  Failed to update ${file.path}: ${error.message}`));
+        }
+      }
+    }
+    const deletedKeys = updates.updates.deleted_keys || [];
+    if (deletedKeys.length > 0) {
+      if (verbose) {
+        console.log(chalk.blue(`\nProcessing ${deletedKeys.length} deleted keys`));
+      }
+      const config = await configService.getValidProjectConfig();
+      const translationFiles = await findTranslationFiles(config, {
+        parseContent: false,
+        includeContent: false,
+        extractKeys: false,
+        verbose
+      });
+
+      if (verbose) {
+        console.log(chalk.blue(`Found ${translationFiles.length} translation files to check for deleted keys`));
+      }
+      const keysToDelete = deletedKeys.map(key => key.name);
+      for (const file of translationFiles) {
+        try {
+          if (verbose) {
+            console.log(chalk.blue(`Checking for deleted keys in ${file.path} (${file.locale})`));
+          }
+
+          const deletedFromFile = await deleteKeysFromTranslationFile(file.path, keysToDelete, file.locale);
+
+          if (deletedFromFile.length > 0) {
+            totalDeleted += deletedFromFile.length;
+
+            if (verbose) {
+              console.log(chalk.green(`✓ Deleted ${deletedFromFile.length} keys from ${file.path}`));
+              for (const key of deletedFromFile) {
+                console.log(chalk.gray(` - ${key}`));
+              }
+            }
+          } else if (verbose) {
+            console.log(chalk.gray(`  No keys to delete in ${file.path}`));
+          }
+        } catch (error) {
+          console.error(chalk.yellow(`⚠️  Failed to delete keys from ${file.path}: ${error.message}`));
+        }
+      }
+    }
+
+    await configService.updateLastSyncedAt();
+
+    return { totalUpdates, totalDeleted };
+  }
+};