@prettifystudio/lyngo-cli 0.1.0 → 0.1.2

package/bin/lyngo

@@ -8,7 +8,8 @@
 //   lyngo whoami                                  who the token belongs to
 //   lyngo init [--languages fr,de] [--primary en] [--workspace <name>] [--yes] [--github]
 //                                                 connect this repository: project, scaffolding, languages, agent hook
-//   lyngo localize [--languages fr,de] [--dry]    localize + translate the working tree's changes
+//   lyngo localize [--languages fr,de] [--no-translate] [--dry]
+//                                                 localize (+ translate) the working tree's changes
 //   lyngo check <file>                            the user-facing strings of one file
 //   lyngo status                                  the project as Lyngo knows it
 //
@@ -386,9 +387,77 @@ async function init(opts) {
   project = await chooseLanguages(project, opts);
   await scaffold(project);
   setUpClaudeCode(top, remote);
+  await fillMissingCatalogs(project, opts);
   console.log('Done. Build as usual; lyngo localize runs when your agent finishes, or run it yourself before committing.');
 }
 
+// A language added today has no catalog in the repository yet; the first
+// `lyngo localize` would create one with the keys of the changed files only
+// (pingcrm, 2026-10-12: 11 of 103 keys). Say so, and fill it on request.
+async function fillMissingCatalogs(project, opts) {
+  const folder = catalogFolder(project);
+  const primary = project.primary_language || 'en';
+  const primaryPath = path.join(folder, primary + '.json');
+  if (!readIfFile(primaryPath)) return;
+  const targets = (project.languages || []).filter((l) => l !== primary);
+  const missing = targets.filter((l) => !readIfFile(path.join(folder, l + '.json')));
+  if (!missing.length) return;
+  const keys = Object.keys(parseCatalog(primaryPath) || {}).length;
+  console.log(`No catalog yet for ${missing.join(', ')}: ${folder}/<code>.json is missing, and ${primary}.json holds ${keys} keys that need translating.`);
+  const go = opts.yes ? 'y' : await ask(`Translate ${missing.length === 1 ? 'it' : 'them'} now? [Y/n] `);
+  if (go !== null && go !== '' && !/^y/i.test(go)) { console.log(`Later: lyngo translate ${missing.join(' ')}`); return; }
+  if (go === null) { console.log(`Run: lyngo translate ${missing.join(' ')}`); return; }
+  for (const code of missing) await translateLanguage(code, project);
+}
+
+function catalogFolder(project) { return ((project.i18n && project.i18n.catalog_folder) || 'lang').replace(/\/+$/, ''); }
+function parseCatalog(p) { try { return JSON.parse(readIfFile(p) || ''); } catch { return null; } }
+
+// ── translate: fill a language's catalog from the primary one ─────────────
+async function translate(opts) {
+  const top = root();
+  process.chdir(top);
+  readToken();
+  const codes = opts._;
+  if (!codes.length) fail('usage: lyngo translate <code> [<code>...]  (fills every key the language lacks)');
+  const st = await call('status', {});
+  const project = { primary_language: st.primary_language, languages: [st.primary_language, ...(st.languages || [])], i18n: st.i18n };
+  for (const code of codes) {
+    if (!project.languages.includes(code)) fail(`${code} is not one of the project's languages (${project.languages.join(', ')}). Add it with lyngo init --languages.`);
+    await translateLanguage(code, project);
+  }
+}
+
+async function translateLanguage(code, project) {
+  const folder = catalogFolder(project);
+  const primary = project.primary_language || 'en';
+  const primaryPath = path.join(folder, primary + '.json');
+  const targetPath = path.join(folder, code + '.json');
+  const source = parseCatalog(primaryPath);
+  if (!source) fail(`${primaryPath} is missing or not valid JSON.`);
+  const current = parseCatalog(targetPath) || {};
+  const missing = Object.keys(source).filter((k) => !(k in current) || String(current[k]).trim() === '');
+  if (!missing.length) { console.log(`${code}: complete, ${Object.keys(source).length} keys.`); return; }
+  let translated = 0, memory = 0, flagged = [];
+  // Chunks keep each request under the server's time; the returned catalog carries forward.
+  for (let i = 0; i < missing.length; i += 100) {
+    const r = await call('translate', {
+      keys: missing.slice(i, i + 100),
+      languages: [code],
+      catalogs: [{ path: primaryPath, content: readIfFile(primaryPath) }, { path: targetPath, content: readIfFile(targetPath) || '{}' }],
+    });
+    const out = (r.catalogs || []).find((c) => c.path === targetPath || c.path.endsWith('/' + code + '.json'));
+    if (!out) fail(`the server returned no catalog for ${code}.`);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, out.content);
+    const l = (r.report && r.report.languages && r.report.languages[code]) || {};
+    translated += l.translated || 0; memory += l.from_memory || 0; flagged.push(...(l.flagged || []));
+    process.stdout.write(`\r${code}: ${Math.min(i + 100, missing.length)}/${missing.length}`);
+  }
+  const flaggedText = flagged.length ? `; ${flagged.length} flagged for review: ${flagged.slice(0, 3).map((x) => JSON.stringify(x.key || x)).join(', ')}` : '';
+  console.log(`\r${code}: ${translated} translated, ${memory} from memory${flaggedText} -> ${targetPath}`);
+}
+
 // ── localize, check, status ────────────────────────────────────────────────
 
 function changedFiles(top) {
@@ -420,6 +489,8 @@ async function localize(opts) {
     const payload = files.map((p) => ({ path: p, content: fs.readFileSync(p, 'utf8') }));
     const args = { files: payload, catalogs: catalogs.map((c) => ({ path: c.path, content: fs.existsSync(c.path) ? fs.readFileSync(c.path, 'utf8') : c.content })), format: 'patch' };
     if (opts.languages) args.languages = opts.languages.filter((l) => l !== status.primary_language);
+    // --no-translate: keys only, catalogs for translators. Without the flag the project's setting decides.
+    if (opts['no-translate']) args.translate = false;
     const r = await call('localize', args);
     if (r.patch && r.patch.trim()) {
       if (opts.dry) { process.stdout.write(r.patch); }
@@ -444,6 +515,7 @@ async function localize(opts) {
   const wrapped = report.files.reduce((n, f) => n + f.wrapped.length, 0);
   console.log(`lyngo: ${wrapped} string${wrapped === 1 ? '' : 's'} localized in ${report.files.length} file${report.files.length === 1 ? '' : 's'}; ${report.added.length} new key${report.added.length === 1 ? '' : 's'}, ${report.reused.length} reused.`);
   for (const f of report.files) console.log(`  ${f.path}: ${f.wrapped.slice(0, 6).map((s) => JSON.stringify(s)).join(', ')}${f.wrapped.length > 6 ? ', …' : ''}`);
+  if (opts['no-translate'] || (status.translate_on_localize === false && !Object.keys(report.languages).length)) console.log('  catalogs: not translated (keys only).');
   for (const [code, l] of Object.entries(report.languages)) {
     const flagged = l.flagged.length ? `; ${l.flagged.length} flagged for review: ${l.flagged.slice(0, 3).map((x) => JSON.stringify(x.key || x)).join(', ')}` : '';
     console.log(`  ${code}: ${l.translated} translated, ${l.from_memory} from memory${flagged}`);
@@ -480,8 +552,10 @@ const HELP = `lyngo ${version()}: localization for your repository, from the ter
   lyngo init [--languages fr,de] [--primary en] [--workspace <name>] [--yes] [--github]
                                     connect this repository: project, i18n setup, languages, agent hook
                                     (--languages are the target languages; the source stays en unless --primary)
-  lyngo localize [--languages fr,de] [--dry]
-                                    localize and translate what changed in the working tree
+  lyngo localize [--languages fr,de] [--no-translate] [--dry]
+                                    localize what changed in the working tree, and translate it
+                                    (--no-translate: keys only; the project setting "Translate when localizing" is the default)
+  lyngo translate <code> [<code>…]  fill every key a language's catalog lacks, from the primary catalog
   lyngo check <file>                the user-facing strings of one file
   lyngo status                      the project as Lyngo knows it
 
@@ -521,6 +595,7 @@ function parse(argv) {
       case 'whoami': await whoami(); break;
       case 'init': await init(opts); break;
       case 'localize': await localize(opts); break;
+      case 'translate': await translate(opts); break;
       case 'check': await check(opts._[0]); break;
       case 'status': await status(); break;
       default: console.error(`lyngo: unknown command "${cmd}".\n\n${HELP}`); process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettifystudio/lyngo-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Localization like code: Lyngo wraps user-facing text, reuses your project's keys and translates the catalogs, from the terminal.",
   "bin": {
     "lyngo": "bin/lyngo"