localingos 0.1.40 → 0.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "localingos",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "description": "CLI tool to sync translations with Localingos",
   "main": "src/index.js",
   "type": "module",

package/src/api.js

@@ -6,36 +6,25 @@ export class LocalingosApi {
         this.apiKey = apiKey;
     }
 
-    async sync(projectId, translatables, { batchSize = 100, onProgress } = {}) {
-        // Push in batches to avoid API timeout
-        const batches = [];
-        for (let i = 0; i < translatables.length; i += batchSize) {
-            batches.push(translatables.slice(i, i + batchSize));
-        }
+    async sync(projectId, translatables, { knownHashes = {}, onProgress } = {}) {
+        const result = await this._post('/sync', {
+            projectId,
+            translatables,
+            knownHashes
+        });
 
-        for (let i = 0; i < batches.length; i++) {
-            await this._post('/translatable', {
+        // Paginate pull if server returned nextPullToken
+        while (result.nextPullToken) {
+            if (onProgress) onProgress('pull');
+            const page = await this._post('/sync/pull', {
                 projectId,
-                translatableList: batches[i]
+                nextPullToken: result.nextPullToken
             });
-            if (onProgress) onProgress(Math.min((i + 1) * batchSize, translatables.length), translatables.length, 'push');
+            if (page.translations) result.translations.push(...page.translations);
+            result.nextPullToken = page.nextPullToken;
         }
 
-        // Pull translations in batches by foreignId
-        const allTranslations = [];
-        const ids = translatables.map(t => t.id);
-        const pullBatchSize = 50;
-        for (let i = 0; i < ids.length; i += pullBatchSize) {
-            const batch = ids.slice(i, i + pullBatchSize);
-            const batchTranslations = await this._post(`/translation/${projectId}/batch`, { foreignIds: batch });
-            if (Array.isArray(batchTranslations)) allTranslations.push(...batchTranslations);
-            if (onProgress) onProgress(Math.min(i + pullBatchSize, ids.length), ids.length, 'pull');
-        }
-
-        const availableIds = new Set(allTranslations.map(t => t.foreignId || t.translatableId));
-        const pending = translatables.filter(t => !availableIds.has(t.id)).map(t => t.id);
-
-        return { translations: allTranslations, pending };
+        return result;
     }
 
     async getTranslatables(projectId) {

package/src/commands/extract.js

@@ -402,8 +402,9 @@ How it works:
 4. If a key is never referenced anywhere (neither by its original export name nor any alias), it's an orphan
 
 Behavior:
+- **Always**: orphan ids are excluded from the JSON output files — they are never written to the source or descriptions JSON, regardless of flags. This prevents them from being synced/translated.
 - **Default run** (\`npm run i18n:extract\`): report orphans with file, export name, record key, and id — grouped by file for readability. Print a message like: \`🧹 N orphan message(s) found — defined but never referenced in code\`
-- **\`--prune\`**: also exclude orphan ids from the JSON output files (so they don't get synced/translated)
+- **\`--prune\`**: also remove stale keys (keys in JSON but no longer in any \`*${msgExt}\` file) from the JSON output files
 - **\`--check\`**: exit with error code if orphans exist (prevents wasting translation budget in CI)
 
 This prevents paying to translate strings that aren't even used in the app.

package/src/commands/mcp-serve.js

@@ -21,6 +21,21 @@ function loadConfig(cwd) {
   return config;
 }
 
+function loadKnownHashes(cwd) {
+  try {
+    const data = JSON.parse(fs.readFileSync(path.join(cwd, '.localingos.json'), 'utf-8'));
+    return data.knownHashes || {};
+  } catch { return {}; }
+}
+
+function saveKnownHashes(cwd, hashes) {
+  const localPath = path.join(cwd, '.localingos.json');
+  let data = {};
+  try { data = JSON.parse(fs.readFileSync(localPath, 'utf-8')); } catch {}
+  data.knownHashes = hashes;
+  fs.writeFileSync(localPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+
 async function api(method, urlPath, apiUrl, apiKey, body) {
   const url = `${apiUrl.replace(/\/+$/, '')}${urlPath}`;
   const opts = { method, headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json', 'Accept': 'application/json' } };
@@ -89,11 +104,36 @@ export async function mcpServeCommand() {
       }
       const entries = readSourceEntries(config, cwd);
       if (!entries.length) return { content: [{ type: 'text', text: 'No source strings found.' }] };
-      const result = await api('POST', '/sync', apiUrl, config.apiKey, { projectId: config.projectId, translatables: entries });
-      const written = writeTranslations(result.translations || [], config, cwd);
+      const knownHashes = loadKnownHashes(cwd);
+      const result = await api('POST', '/sync', apiUrl, config.apiKey, { projectId: config.projectId, translatables: entries, knownHashes });
+      const translations = result.translations || [];
+      // Paginate pull
+      while (result.nextPullToken) {
+        const page = await api('POST', '/sync/pull', apiUrl, config.apiKey, { projectId: config.projectId, nextPullToken: result.nextPullToken });
+        if (page.translations) translations.push(...page.translations);
+        result.nextPullToken = page.nextPullToken;
+      }
+      if (translations.length > 0) {
+        const changedLocales = new Set(translations.filter(t => t.locale !== config.sourceLocale).map(t => t.locale));
+        const outputDir = path.resolve(cwd, config.outputDir);
+        for (const locale of changedLocales) {
+          const existing = {};
+          const fileName = (config.outputPattern || '{locale}.json').replace('{locale}', locale);
+          const filePath = path.join(outputDir, fileName);
+          if (fs.existsSync(filePath)) {
+            try { for (const e of flatten(JSON.parse(fs.readFileSync(filePath, 'utf-8')))) existing[e.id] = { foreignId: e.id, text: e.text, locale }; } catch {}
+          }
+          for (const t of translations.filter(t => t.locale === locale)) existing[t.foreignId] = t;
+          writeTranslations(Object.values(existing), config, cwd);
+        }
+      }
+      if (result.hashes) saveKnownHashes(cwd, result.hashes);
+      const push = result.push || {};
       const pending = result.pending || [];
-      const lines = [`Pushed ${entries.length} source strings`, `${(result.translations || []).length} translations available`,
-        pending.length ? `${pending.length} keys pending` : null, written.length ? `Written: ${written.join(', ')}` : null,
+      const lines = [
+        `Push: ${push.created || 0} created, ${push.updated || 0} updated, ${push.deleted || 0} deleted, ${push.unchanged || 0} unchanged`,
+        `${translations.length} new translations received`,
+        pending.length ? `${pending.length} keys pending` : null,
         extractOut ? `\n${extractOut}` : null].filter(Boolean);
       return { content: [{ type: 'text', text: lines.join('\n') }] };
     }

package/src/commands/sync.js

@@ -6,6 +6,23 @@ import { loadConfig, resolveApiUrl } from '../config.js';
 import { LocalingosApi } from '../api.js';
 import { getFormatter } from '../formats/index.js';
 
+const LOCAL_CONFIG_FILE = '.localingos.json';
+
+function loadKnownHashes() {
+    try {
+        const data = JSON.parse(fs.readFileSync(path.resolve(LOCAL_CONFIG_FILE), 'utf-8'));
+        return data.knownHashes || {};
+    } catch { return {}; }
+}
+
+function saveKnownHashes(hashes) {
+    const localPath = path.resolve(LOCAL_CONFIG_FILE);
+    let data = {};
+    try { data = JSON.parse(fs.readFileSync(localPath, 'utf-8')); } catch {}
+    data.knownHashes = hashes;
+    fs.writeFileSync(localPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+
 export async function syncCommand(options) {
     const config = loadConfig(options.config);
     const apiUrl = resolveApiUrl(options.env);
@@ -72,68 +89,64 @@ export async function syncCommand(options) {
     // 2. Call /sync endpoint (push + pull in one call)
     console.log(chalk.blue(`\n🔄 Syncing with Localingos (project: ${config.projectId})...`));
     const api = new LocalingosApi(apiUrl, config.apiKey);
+    const knownHashes = loadKnownHashes();
 
     let result;
     try {
-        result = await api.sync(config.projectId, translatables, {
-            onProgress: (done, total, phase) => {
-                const label = phase === 'push' ? 'Pushed' : 'Pulled';
-                process.stdout.write(`\r   ${label} ${done}/${total} strings...`);
-            }
-        });
-        process.stdout.write('\n');
+        result = await api.sync(config.projectId, translatables, { knownHashes });
     } catch (e) {
         console.error(chalk.red(`\nSync failed: ${e.message}`));
         process.exit(1);
     }
 
-    const translations = result.translations || [];
-    const pending = result.pending || [];
-    console.log(chalk.green(`   ✅ ${translations.length} translations available`));
+    const { push, translations = [], hashes = {}, pending = [] } = result;
+    if (push) {
+        console.log(chalk.gray(`   Push: ${push.created} created, ${push.updated} updated, ${push.deleted} deleted, ${push.unchanged} unchanged`));
+    }
+    console.log(chalk.green(`   ✅ ${translations.length} translations received`));
     if (pending.length > 0) {
         console.log(chalk.yellow(`   ⏳ ${pending.length} keys pending translation: ${pending.slice(0, 5).join(', ')}${pending.length > 5 ? '...' : ''}`));
     }
 
-    // 2b. Prune stale translatables from the remote project
-    if (options.prune) {
-        console.log(chalk.blue('\n🔍 Checking for stale translatables in the remote project...'));
-        try {
-            const remoteTranslatables = await api.getTranslatables(config.projectId);
-            const localIds = new Set(translatables.map(t => t.id));
-            const staleIds = remoteTranslatables
-                .filter(t => !localIds.has(t.foreignId || t.id))
-                .map(t => t.foreignId || t.id);
-
-            if (staleIds.length > 0) {
-                console.log(chalk.yellow(`   Found ${staleIds.length} stale translatable(s) not in source file:`));
-                for (const id of staleIds.slice(0, 10)) {
-                    console.log(chalk.gray(`     - ${id}`));
-                }
-                if (staleIds.length > 10) console.log(chalk.gray(`     ... and ${staleIds.length - 10} more`));
-
-                const deleteResult = await api.deleteTranslatables(config.projectId, staleIds);
-                console.log(chalk.green(`   🗑️  Deleted ${deleteResult.deleted} stale translatable(s) from remote`));
-            } else {
-                console.log(chalk.green('   ✅ No stale translatables found'));
-            }
-        } catch (e) {
-            console.error(chalk.yellow(`   ⚠️  Could not prune remote translatables: ${e.message}`));
-        }
-    }
+    // Save updated hashes
+    saveKnownHashes(hashes);
 
-    // 3. Write translation files (skip source locale to avoid overwriting the source file)
+    // 3. Write translation files — merge new translations into existing files
     const targetTranslations = translations.filter(t => t.locale !== config.sourceLocale);
 
     if (targetTranslations.length > 0) {
         const outputDir = path.resolve(config.outputDir);
         console.log(chalk.blue(`\n📝 Writing translation files to ${outputDir}`));
 
-        const writtenFiles = formatter.write(targetTranslations, outputDir, config.outputPattern);
-        for (const file of writtenFiles) {
-            console.log(chalk.green(`   ✅ ${file}`));
+        // Only rewrite locale files that have new/updated translations
+        const changedLocales = new Set(targetTranslations.map(t => t.locale));
+
+        for (const locale of changedLocales) {
+            const pattern = (config.outputPattern || '{locale}.json');
+            const fileName = pattern.replace('{locale}', locale);
+            const filePath = path.join(outputDir, fileName);
+
+            // Read existing translations for this locale from disk
+            const existing = {};
+            if (fs.existsSync(filePath)) {
+                try {
+                    for (const e of formatter.extract(filePath)) {
+                        existing[e.id] = { foreignId: e.id, text: e.text, locale };
+                    }
+                } catch {}
+            }
+
+            // Merge: new translations override existing
+            for (const t of targetTranslations.filter(t => t.locale === locale)) {
+                existing[t.foreignId] = t;
+            }
+
+            const merged = Object.values(existing);
+            formatter.write(merged, outputDir, config.outputPattern);
+            console.log(chalk.green(`   ✅ ${filePath}`));
         }
     } else {
-        console.log(chalk.yellow('\n   No translations available yet. Run "localingos sync" again later.'));
+        console.log(chalk.yellow('\n   No new translations. Run "localingos sync" again later.'));
     }
 
     console.log(chalk.blue('\n✨ Sync complete!\n'));