@p6t/cli 0.1.0

package/dist/lingui-VSOT4HY4.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+// src/catalog/lingui.ts
+import fs from "fs";
+import path from "path";
+import { po } from "gettext-parser";
+import { getConfig } from "@lingui/conf";
+function loadLinguiConfig(cwd) {
+  try {
+    const config = getConfig({ cwd, skipValidation: true });
+    return {
+      rootDir: config.rootDir,
+      locales: config.locales,
+      catalogPaths: config.catalogs.map((catalog) => ({
+        path: catalog.path
+      }))
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveCatalogPath(template, locale, rootDir) {
+  const resolved = template.replace("<rootDir>", rootDir).replace("{locale}", locale);
+  return path.resolve(resolved + ".po");
+}
+function makeId(msgctxt, msgid) {
+  return msgctxt ? `${msgctxt}${msgid}` : msgid;
+}
+function isFuzzy(entry) {
+  return entry.comments?.flag?.includes("fuzzy") ?? false;
+}
+function parsePo(filePath) {
+  try {
+    return po.parse(fs.readFileSync(filePath));
+  } catch {
+    return null;
+  }
+}
+function discoverPoFiles(cwd) {
+  const candidates = [];
+  for (const dir of ["locale", "locales", "src/locales", "src/locale"]) {
+    const full = path.join(cwd, dir);
+    if (!fs.existsSync(full)) continue;
+    for (const entry of fs.readdirSync(full, {
+      recursive: true
+    })) {
+      if (entry.endsWith(".po")) candidates.push(path.join(full, entry));
+    }
+  }
+  return candidates;
+}
+function refFile(ref) {
+  const idx = ref.lastIndexOf(":");
+  return idx >= 0 ? ref.slice(0, idx) : ref;
+}
+function createLinguiAdapter(configDir, _catalogs) {
+  let linguiProject = null;
+  function ensureLinguiProject() {
+    if (!linguiProject) {
+      linguiProject = loadLinguiConfig(configDir);
+      if (!linguiProject) {
+        throw new Error(
+          "No lingui config found. Make sure lingui.config.ts (or equivalent) exists."
+        );
+      }
+    }
+    return linguiProject;
+  }
+  function getCatalogPathsForLocale(locale) {
+    const project = ensureLinguiProject();
+    return project.catalogPaths.map(
+      (catalog) => resolveCatalogPath(catalog.path, locale, project.rootDir)
+    );
+  }
+  return {
+    getCatalogPathsForLocale,
+    readPendingTranslations(targetPath, sourcePath) {
+      let targetPo = null;
+      if (fs.existsSync(targetPath)) {
+        try {
+          targetPo = po.parse(fs.readFileSync(targetPath));
+        } catch {
+          targetPo = null;
+        }
+      }
+      if (!fs.existsSync(sourcePath)) return { groups: [] };
+      const sourcePo = po.parse(fs.readFileSync(sourcePath));
+      const unitsByFile = /* @__PURE__ */ new Map();
+      for (const [ctx, entries] of Object.entries(sourcePo.translations)) {
+        for (const [msgid, entry] of Object.entries(entries)) {
+          if (!msgid) continue;
+          const id = makeId(ctx || void 0, msgid);
+          const targetEntry = targetPo?.translations[ctx]?.[msgid];
+          const existingTranslation = targetEntry?.msgstr?.[0];
+          if (existingTranslation && existingTranslation.trim() !== "" && targetEntry && !isFuzzy(targetEntry)) {
+            continue;
+          }
+          const unit = {
+            id,
+            source: entry.msgid
+          };
+          if (entry.msgid_plural) unit.sourcePlural = entry.msgid_plural;
+          const extracted = entry.comments?.extracted;
+          if (extracted) unit.context = extracted;
+          const refs = entry.comments?.reference;
+          if (refs) {
+            unit.references = refs.split("\n").filter(Boolean);
+          }
+          const file = unit.references?.[0] ? refFile(unit.references[0]) : sourcePath;
+          const group = unitsByFile.get(file);
+          if (group) {
+            group.push(unit);
+          } else {
+            unitsByFile.set(file, [unit]);
+          }
+        }
+      }
+      const hasReferences = unitsByFile.size > 0 && Array.from(unitsByFile.values()).some(
+        (units) => units.some((u) => u.references != null && u.references.length > 0)
+      );
+      const groups = [];
+      for (const [sourceFile, units] of unitsByFile) {
+        groups.push({ sourceFile, hasSourceRefs: hasReferences, units });
+      }
+      return { groups };
+    },
+    writeTranslations(filePath, sourceFilePath, results) {
+      const resultMap = new Map(results.map((r) => [r.id, r.translation]));
+      let catalog;
+      if (fs.existsSync(filePath)) {
+        catalog = po.parse(fs.readFileSync(filePath));
+      } else {
+        const source = po.parse(fs.readFileSync(sourceFilePath));
+        catalog = {
+          charset: source.charset,
+          headers: { ...source.headers },
+          translations: {}
+        };
+      }
+      for (const result of results) {
+        const sepIdx = result.id.indexOf("");
+        const ctx = sepIdx >= 0 ? result.id.slice(0, sepIdx) : "";
+        const msgid = sepIdx >= 0 ? result.id.slice(sepIdx + 1) : result.id;
+        if (!catalog.translations[ctx]) catalog.translations[ctx] = {};
+        const existing = catalog.translations[ctx][msgid];
+        const { flag: _flag, ...commentsWithoutFlag } = existing?.comments ?? {};
+        catalog.translations[ctx][msgid] = {
+          ...existing ?? { msgid },
+          msgstr: [resultMap.get(result.id) ?? ""],
+          comments: commentsWithoutFlag
+        };
+      }
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, po.compile(catalog));
+    },
+    removeStaleKeys(filePath, sourceFilePath) {
+      if (!fs.existsSync(filePath) || !fs.existsSync(sourceFilePath)) {
+        return [];
+      }
+      const catalog = po.parse(fs.readFileSync(filePath));
+      const source = po.parse(fs.readFileSync(sourceFilePath));
+      const orphans = [];
+      let modified = false;
+      for (const ctx of Object.keys(catalog.translations)) {
+        for (const msgid of Object.keys(catalog.translations[ctx])) {
+          if (!msgid) continue;
+          if (!source.translations[ctx]?.[msgid]) {
+            const entry = catalog.translations[ctx][msgid];
+            orphans.push({
+              id: makeId(ctx || void 0, msgid),
+              source: entry.msgid,
+              translation: entry.msgstr?.[0] ?? "",
+              context: entry.comments?.extracted
+            });
+            delete catalog.translations[ctx][msgid];
+            modified = true;
+          }
+        }
+        if (Object.keys(catalog.translations[ctx]).length === 0) {
+          delete catalog.translations[ctx];
+        }
+      }
+      if (modified) {
+        fs.writeFileSync(filePath, po.compile(catalog));
+      }
+      return orphans;
+    },
+    discoverCatalogs(cwd) {
+      return discoverPoFiles(cwd);
+    },
+    extractSourceStrings(filePath) {
+      const catalog = parsePo(filePath);
+      if (!catalog) return [];
+      const strings = [];
+      for (const entries of Object.values(catalog.translations)) {
+        for (const [msgid, entry] of Object.entries(entries)) {
+          if (!msgid) continue;
+          strings.push(entry.msgid);
+        }
+      }
+      return [...new Set(strings)];
+    },
+    extractTranslatedPairs(filePath, _sourceFilePath) {
+      const catalog = parsePo(filePath);
+      if (!catalog) return [];
+      const pairs = [];
+      for (const entries of Object.values(catalog.translations)) {
+        for (const [msgid, entry] of Object.entries(entries)) {
+          if (!msgid) continue;
+          const translation = entry.msgstr?.[0];
+          if (translation && translation.trim()) {
+            pairs.push({ source: entry.msgid, translation });
+          }
+        }
+      }
+      return pairs;
+    }
+  };
+}
+export {
+  createLinguiAdapter
+};

package/dist/react-intl-EIVHSW57.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+// src/catalog/react-intl.ts
+import fs from "fs";
+import path from "path";
+function resolveCatalogPath(template, locale, configDir) {
+  return path.resolve(configDir, template.replace("{locale}", locale));
+}
+function readJsonSafe(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isRichCatalog(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const values = Object.values(obj);
+  if (values.length === 0) return false;
+  return values.every(
+    (entry) => typeof entry === "object" && entry !== null && "defaultMessage" in entry && typeof entry.defaultMessage === "string"
+  );
+}
+function discoverJsonFiles(cwd) {
+  const candidates = [];
+  const dirs = [
+    "lang",
+    "src/lang",
+    "messages",
+    "src/messages",
+    "i18n",
+    "locales",
+    "src/locales",
+    "src/i18n"
+  ];
+  for (const dir of dirs) {
+    const full = path.join(cwd, dir);
+    if (!fs.existsSync(full)) continue;
+    for (const entry of fs.readdirSync(full, { recursive: true })) {
+      if (entry.endsWith(".json")) {
+        candidates.push(path.join(full, entry));
+      }
+    }
+  }
+  return candidates;
+}
+function createReactIntlAdapter(configDir, catalogs) {
+  if (!catalogs || catalogs.length === 0) {
+    throw new Error(
+      "react-intl adapter requires catalogs configured in i18n.json"
+    );
+  }
+  function getCatalogPathsForLocale(locale) {
+    return catalogs.map((c) => resolveCatalogPath(c.path, locale, configDir));
+  }
+  return {
+    getCatalogPathsForLocale,
+    readPendingTranslations(targetPath, sourcePath) {
+      const sourceCatalog = readJsonSafe(sourcePath);
+      if (!sourceCatalog) return { groups: [] };
+      const targetCatalog = readJsonSafe(targetPath) ?? {};
+      const isRich = isRichCatalog(sourceCatalog);
+      const unitsByFile = /* @__PURE__ */ new Map();
+      let hasReferences = false;
+      for (const [id, entry] of Object.entries(sourceCatalog)) {
+        const targetValue = targetCatalog[id];
+        if (typeof targetValue?.defaultMessage === "string" && targetValue.defaultMessage.trim() !== "") {
+          continue;
+        }
+        const unit = { id, source: "" };
+        if (isRich) {
+          const richEntry = entry;
+          unit.source = richEntry.defaultMessage;
+          if (richEntry.description) unit.context = richEntry.description;
+          if (richEntry.file != null && richEntry.line != null) {
+            unit.references = [`${richEntry.file}:${richEntry.line}`];
+            hasReferences = true;
+          }
+        } else {
+          unit.source = entry;
+        }
+        if (!unit.source) continue;
+        const file = unit.references?.[0]?.split(":")[0] ?? sourcePath;
+        const group = unitsByFile.get(file);
+        if (group) {
+          group.push(unit);
+        } else {
+          unitsByFile.set(file, [unit]);
+        }
+      }
+      if (!hasReferences && unitsByFile.size > 0) {
+        console.warn(
+          "[p6t] Source file references not found in react-intl catalog. Translations will be grouped by catalog file instead of by component. For better results, run `formatjs extract` with `--extract-source-location`."
+        );
+      }
+      const groups = [];
+      for (const [sourceFile, units] of unitsByFile) {
+        groups.push({ sourceFile, hasSourceRefs: hasReferences, units });
+      }
+      return { groups };
+    },
+    writeTranslations(targetPath, sourcePath, results) {
+      const sourceCatalog = readJsonSafe(
+        sourcePath
+      );
+      const isRich = sourceCatalog ? isRichCatalog(sourceCatalog) : false;
+      const sourceMap = sourceCatalog ? new Map(Object.entries(sourceCatalog)) : /* @__PURE__ */ new Map();
+      let catalog;
+      if (fs.existsSync(targetPath)) {
+        catalog = readJsonSafe(targetPath) ?? {};
+      } else {
+        catalog = {};
+      }
+      for (const result of results) {
+        const sourceEntry = sourceMap.get(result.id);
+        const entry = {
+          defaultMessage: result.translation
+        };
+        if (isRich && sourceEntry && typeof sourceEntry === "object") {
+          const rich = sourceEntry;
+          if (rich.description) entry._p6t_description = rich.description;
+          entry._p6t_source = rich.defaultMessage;
+        } else if (typeof sourceEntry === "string") {
+          entry._p6t_source = sourceEntry;
+        }
+        catalog[result.id] = entry;
+      }
+      const ordered = {};
+      if (sourceCatalog) {
+        for (const id of Object.keys(sourceCatalog)) {
+          if (id in catalog) {
+            ordered[id] = catalog[id];
+          }
+        }
+      }
+      for (const [id, entry] of Object.entries(catalog)) {
+        if (!(id in ordered)) {
+          ordered[id] = entry;
+        }
+      }
+      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+      fs.writeFileSync(targetPath, JSON.stringify(ordered, null, 2) + "\n");
+    },
+    removeStaleKeys(targetPath, sourcePath) {
+      if (!fs.existsSync(targetPath)) return [];
+      const catalog = readJsonSafe(targetPath) ?? {};
+      const sourceCatalog = readJsonSafe(
+        sourcePath
+      );
+      if (!sourceCatalog) return [];
+      const orphans = [];
+      let modified = false;
+      for (const id of Object.keys(catalog)) {
+        if (!(id in sourceCatalog)) {
+          const entry = catalog[id];
+          orphans.push({
+            id,
+            source: entry._p6t_source,
+            translation: entry.defaultMessage,
+            context: entry._p6t_description
+          });
+          delete catalog[id];
+          modified = true;
+        }
+      }
+      if (modified) {
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, JSON.stringify(catalog, null, 2) + "\n");
+      }
+      return orphans;
+    },
+    discoverCatalogs(cwd) {
+      return discoverJsonFiles(cwd);
+    },
+    extractSourceStrings(filePath) {
+      const catalog = readJsonSafe(filePath);
+      if (!catalog) return [];
+      const isRich = isRichCatalog(catalog);
+      const strings = [];
+      for (const [id, entry] of Object.entries(catalog)) {
+        if (!id) continue;
+        if (isRich) {
+          strings.push(entry.defaultMessage);
+        } else {
+          strings.push(entry);
+        }
+      }
+      return [...new Set(strings)];
+    },
+    extractTranslatedPairs(filePath, sourceFilePath) {
+      const catalog = readJsonSafe(filePath);
+      if (!catalog) return [];
+      let sourceCatalog = null;
+      if (sourceFilePath) {
+        sourceCatalog = readJsonSafe(
+          sourceFilePath
+        );
+      }
+      const pairs = [];
+      const isSourceRich = sourceCatalog ? isRichCatalog(sourceCatalog) : false;
+      for (const [id, entry] of Object.entries(catalog)) {
+        const translation = entry.defaultMessage;
+        if (!translation?.trim()) continue;
+        let source = id;
+        if (sourceCatalog) {
+          const sourceEntry = sourceCatalog[id];
+          if (isSourceRich && sourceEntry && typeof sourceEntry === "object" && sourceEntry !== null) {
+            source = sourceEntry.defaultMessage;
+          } else if (typeof sourceEntry === "string") {
+            source = sourceEntry;
+          }
+        }
+        pairs.push({ source, translation });
+      }
+      return pairs;
+    }
+  };
+}
+export {
+  createReactIntlAdapter
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@p6t/cli",
+  "version": "0.1.0",
+  "description": "Developer CLI for p6t — extract, push, pull, and check translation coverage",
+  "type": "module",
+  "bin": {
+    "p6t": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "i18n",
+    "translation",
+    "cli",
+    "polyglot"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/gettext-parser": "^9.0.0",
+    "@types/node": "^25.6.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.6"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.72",
+    "@ai-sdk/google": "^3.0.65",
+    "@ai-sdk/mistral": "^3.0.31",
+    "@ai-sdk/openai": "^3.0.54",
+    "@clack/prompts": "^1.2.0",
+    "@lingui/conf": "^6.0.0",
+    "@openrouter/ai-sdk-provider": "^2.9.0",
+    "ai": "^6.0.169",
+    "ai-sdk-ollama": "^3.8.3",
+    "citty": "^0.2.2",
+    "gettext-parser": "^9.0.2",
+    "zod": "^4.4.3",
+    "@p6t/config": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  }
+}