@localheroai/cli 0.0.2 → 0.0.5

package/src/utils/github.js

@@ -2,22 +2,45 @@ 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;
+  },
+
+  isGitHubAction() {
+    return this.deps.env.GITHUB_ACTIONS === 'true';
+  },
 
-export async function createGitHubActionFile(basePath, translationPaths) {
-  const workflowDir = path.join(basePath, '.github', 'workflows');
-  const workflowFile = path.join(workflowDir, 'localhero-translate.yml');
+  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 });
+    await fs.mkdir(workflowDir, { recursive: true });
 
-  const actionContent = `name: Localhero.ai - I18n translation
+    const actionContent = `name: Localhero.ai - I18n translation
 
 on:
   pull_request:
     paths:
-      ${translationPaths.map(p => `- "${p}"`).join('\n      ')}
+      ${translationPaths.map(p => {
+      // Check if path already contains a file pattern (*, ?, or {})
+      const hasPattern = /[*?{}]/.test(p);
+      // If it has a pattern, use it as is; otherwise, append /**
+      const formattedPath = hasPattern ? p : `${p}${p.endsWith('/') ? '' : '/'}**`;
+      return `- "${formattedPath}"`;
+    }).join('\n      ')}
 
 jobs:
   translate:
@@ -36,57 +59,70 @@ jobs:
     - name: Set up Node.js
       uses: actions/setup-node@v4
       with:
-        node-version: 18
+        node-version: 22
 
     - 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;
-}
+    await fs.writeFile(workflowFile, actionContent);
+    return workflowFile;
+  },
 
-export function autoCommitChanges(filesPath) {
-  if (!isGitHubAction()) return;
+  autoCommitChanges(filesPath) {
+    const { exec, env } = this.deps;
 
-  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 "hi@localhero.ai"', { stdio: "inherit" });
+    if (!this.isGitHubAction()) return;
 
-    const branchName = process.env.GITHUB_HEAD_REF;
-    if (!branchName) {
-      throw new Error('Could not determine branch name from GITHUB_HEAD_REF');
-    }
+    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" });
 
-    execSync(`git add ${filesPath}`, { stdio: "inherit" });
+      const branchName = env.GITHUB_HEAD_REF;
+      if (!branchName) {
+        throw new Error('Could not determine branch name from GITHUB_HEAD_REF');
+      }
 
-    const status = execSync('git status --porcelain').toString();
-    if (!status) {
-      console.log("No changes to commit.");
-      return;
-    }
+      exec(`git add ${filesPath}`, { stdio: "inherit" });
 
-    execSync('git commit -m "Update translations"', { stdio: "inherit" });
+      const status = exec('git status --porcelain').toString();
+      if (!status) {
+        console.log("No changes to commit.");
+        return;
+      }
 
-    const token = process.env.GITHUB_TOKEN;
-    if (!token) {
-      throw new Error('GITHUB_TOKEN is not set');
-    }
+      exec('git commit -m "Update translations"', { stdio: "inherit" });
 
-    const repository = process.env.GITHUB_REPOSITORY;
-    if (!repository) {
-      throw new Error('GITHUB_REPOSITORY is not set');
-    }
+      const token = env.GITHUB_TOKEN;
+      if (!token) {
+        throw new Error('GITHUB_TOKEN is not set');
+      }
 
-    const remoteUrl = `https://x-access-token:${token}@github.com/${repository}.git`;
+      const repository = env.GITHUB_REPOSITORY;
+      if (!repository) {
+        throw new Error('GITHUB_REPOSITORY is not set');
+      }
 
-    execSync(`git remote set-url origin ${remoteUrl}`, { stdio: "inherit" });
-    execSync(`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;
+      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,146 +1,128 @@
 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.import?.status === 'failed') {
+      return {
+        ...importResult.import,
+        files: importedFiles
+      };
+    }
+
+    let finalImportResult = importResult;
+    while (finalImportResult.import?.status === 'processing') {
+      await new Promise(resolve => setTimeout(resolve, finalImportResult.import.poll_interval * 1000));
+      finalImportResult = await checkImportStatus(config.projectId, finalImportResult.import.id);
+
+      if (finalImportResult.import?.status === 'failed') {
         return {
-            ...finalTargetImport,
-            sourceImport: finalSourceImport,
-            files: importedFiles
+          ...finalImportResult.import,
+          files: importedFiles
         };
+      }
     }
-}; 
+
+    const { import: { 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)
+      };
+    }
+  };
+}