@localheroai/cli 0.0.1

package/src/utils/import-service.js

@@ -0,0 +1,146 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+import { createImport, checkImportStatus } from '../api/imports.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');
+    return Buffer.from(content).toString('base64');
+}
+
+function getLanguageFromPath(filePath, sourceLocale) {
+    const fileName = path.basename(filePath, path.extname(filePath));
+    return fileName === sourceLocale ? sourceLocale : fileName;
+}
+
+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
+        };
+
+        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
+                };
+            }
+        }
+
+        return {
+            ...finalTargetImport,
+            sourceImport: finalSourceImport,
+            files: importedFiles
+        };
+    }
+}; 

package/src/utils/project-service.js

@@ -0,0 +1,11 @@
+import { createProject as apiCreateProject, listProjects as apiListProjects } from '../api/projects.js';
+
+export const defaultProjectService = {
+    async createProject({ name, sourceLocale, targetLocales }) {
+        return apiCreateProject({ name, sourceLocale, targetLocales });
+    },
+
+    async listProjects() {
+        return apiListProjects();
+    }
+}; 

package/src/utils/prompt-service.js

@@ -0,0 +1,51 @@
+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);
+        }
+    };
+} 

package/src/utils/translation-updater.js

@@ -0,0 +1,154 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+
+function getExistingQuoteStyles(content) {
+    const styles = new Map();
+
+    // Pre-split lines and get non-empty, non-comment lines
+    const lines = content.match(/[^\n]+/g) || [];
+    let currentPath = new Array(10); // Pre-allocate array with reasonable size
+    let pathLength = 0;
+
+    // Regex patterns - compile once
+    const indentRegex = /^\s*/;
+    const keyValueRegex = /^([^:]+):\s*(.*)$/;
+    const doubleQuoteRegex = /^"(.*)"$/;
+    const singleQuoteRegex = /^'(.*)'$/;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || line.trim().startsWith('#')) continue;
+
+        // Calculate indent level
+        const indent = line.match(indentRegex)[0].length;
+        const level = indent >> 1; // Divide by 2 using bit shift
+
+        // Adjust current path
+        pathLength = level;
+
+        // Extract key and value
+        const match = line.trim().match(keyValueRegex);
+        if (match) {
+            const key = match[1].trim();
+            const value = match[2];
+
+            currentPath[level] = key;
+
+            // Only process if there's a value
+            if (value) {
+                // Build path string only when needed
+                const fullPath = currentPath.slice(0, pathLength + 1).join('.');
+
+                // Check quote style
+                const valueTrimed = value.trim();
+                const hasDoubleQuotes = doubleQuoteRegex.test(valueTrimed);
+                const hasSingleQuotes = !hasDoubleQuotes && singleQuoteRegex.test(valueTrimed);
+
+                if (hasDoubleQuotes || hasSingleQuotes || valueTrimed) {
+                    styles.set(fullPath, {
+                        quoted: hasDoubleQuotes || hasSingleQuotes,
+                        quoteType: hasDoubleQuotes ? '"' : (hasSingleQuotes ? "'" : ''),
+                        originalValue: valueTrimed
+                    });
+                }
+            }
+        }
+    }
+
+    return styles;
+}
+
+// Cache for repeated string operations
+const SPECIAL_CHARS_REGEX = /[:@#,\[\]{}?|>&*!\n]/;
+const INTERPOLATION = '%{';
+const INDENT_CACHE = new Map();
+
+function getIndent(level) {
+    let indent = INDENT_CACHE.get(level);
+    if (!indent) {
+        indent = ' '.repeat(level);
+        INDENT_CACHE.set(level, indent);
+    }
+    return indent;
+}
+
+function stringifyYaml(obj, indent = 0, parentPath = '', result = []) {
+    const indentStr = getIndent(indent);
+
+    for (const [key, value] of Object.entries(obj)) {
+        const currentPath = parentPath ? `${parentPath}.${key}` : key;
+
+        if (value && typeof value === 'object') {
+            result.push(`${indentStr}${key}:`);
+            stringifyYaml(value, indent + 2, currentPath, result);
+        } else {
+            let formattedValue = value;
+
+            if (typeof value === 'string') {
+                const existingStyle = existingStyles.get(currentPath);
+
+                if (existingStyle?.quoted) {
+                    formattedValue = `${existingStyle.quoteType}${value}${existingStyle.quoteType}`;
+                } else if (existingStyle?.originalValue === value) {
+                    formattedValue = existingStyle.originalValue;
+                } else if (value.includes(INTERPOLATION) || SPECIAL_CHARS_REGEX.test(value)) {
+                    formattedValue = `"${value}"`;
+                }
+            }
+
+            result.push(`${indentStr}${key}: ${formattedValue}`);
+        }
+    }
+
+    return result;
+}
+
+// Store styles globally to avoid passing as parameter
+let existingStyles;
+
+export async function updateTranslationFile(filePath, translations, languageCode) {
+    try {
+        if (path.extname(filePath).slice(1) === 'json') {
+            // Handle JSON (existing code)
+            return;
+        }
+
+        let existingContent = '';
+
+        try {
+            existingContent = await fs.readFile(filePath, 'utf8');
+            existingStyles = getExistingQuoteStyles(existingContent);
+        } catch (error) {
+            console.warn(`Creating new file: ${filePath}`);
+            existingStyles = new Map();
+        }
+
+        // Parse existing content
+        const yamlContent = yaml.parse(existingContent) || {};
+        yamlContent[languageCode] = yamlContent[languageCode] || {};
+
+        // Update translations efficiently
+        for (const [keyPath, newValue] of Object.entries(translations)) {
+            const keys = keyPath.split('.');
+            let current = yamlContent[languageCode];
+            const lastIndex = keys.length - 1;
+
+            for (let i = 0; i < lastIndex; i++) {
+                const key = keys[i];
+                current[key] = current[key] || {};
+                current = current[key];
+            }
+
+            current[keys[lastIndex]] = newValue;
+        }
+
+        const content = stringifyYaml(yamlContent);
+
+        await fs.writeFile(filePath, content.join('\n'));
+        return Object.keys(translations);
+
+    } catch (error) {
+        throw new Error(`Failed to update translation file ${filePath}: ${error.message}`);
+    }
+}