@arcote.tech/arc-cli 0.3.1 → 0.4.2

package/src/i18n/catalog.ts

@@ -0,0 +1,204 @@
+/**
+ * PO-like catalog format for Arc i18n.
+ *
+ * Format:
+ *   #: relative/path/to/file.tsx:42
+ *   #. hash:a1b2c3d4
+ *   msgid "Original text"
+ *   msgstr "Translation"
+ *
+ * Obsolete entries (no longer in source):
+ *   #~ msgid "Removed text"
+ *   #~ msgstr "Old translation"
+ */
+
+export interface CatalogEntry {
+  msgid: string;
+  msgstr: string;
+  locations: string[];
+  hash: string;
+  obsolete: boolean;
+}
+
+/** Short hash from msgid for change tracking */
+export function hashMsgid(msgid: string): string {
+  const hasher = new Bun.CryptoHasher("md5");
+  hasher.update(msgid);
+  return hasher.digest("hex").slice(0, 8);
+}
+
+/** Parse a .po file into catalog entries */
+export function parsePo(content: string): CatalogEntry[] {
+  const entries: CatalogEntry[] = [];
+  const lines = content.split("\n");
+
+  let locations: string[] = [];
+  let hash = "";
+  let msgid = "";
+  let msgstr = "";
+  let obsolete = false;
+
+  const flush = () => {
+    if (msgid) {
+      entries.push({
+        msgid,
+        msgstr,
+        locations,
+        hash: hash || hashMsgid(msgid),
+        obsolete,
+      });
+    }
+    locations = [];
+    hash = "";
+    msgid = "";
+    msgstr = "";
+    obsolete = false;
+  };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed === "" || trimmed.startsWith("#,")) {
+      // Empty line or flags — boundary between entries
+      if (msgid) flush();
+      continue;
+    }
+
+    // Location comment
+    if (trimmed.startsWith("#:")) {
+      if (msgid) flush(); // new entry starting
+      locations.push(trimmed.slice(3).trim());
+      continue;
+    }
+
+    // Hash comment
+    if (trimmed.startsWith("#.")) {
+      const hashMatch = trimmed.match(/hash:(\w+)/);
+      if (hashMatch) hash = hashMatch[1];
+      continue;
+    }
+
+    // Obsolete entry
+    if (trimmed.startsWith("#~")) {
+      const rest = trimmed.slice(3).trim();
+      if (rest.startsWith("msgid")) {
+        if (msgid) flush();
+        obsolete = true;
+        msgid = extractQuoted(rest.slice(5));
+      } else if (rest.startsWith("msgstr")) {
+        msgstr = extractQuoted(rest.slice(6));
+      }
+      continue;
+    }
+
+    // Regular msgid/msgstr
+    if (trimmed.startsWith("msgid")) {
+      if (msgid) flush();
+      msgid = extractQuoted(trimmed.slice(5));
+    } else if (trimmed.startsWith("msgstr")) {
+      msgstr = extractQuoted(trimmed.slice(6));
+    }
+  }
+
+  // Flush last entry
+  flush();
+
+  return entries;
+}
+
+/** Write catalog entries to .po format */
+export function writePo(entries: CatalogEntry[]): string {
+  const lines: string[] = [];
+
+  // Active entries first, then obsolete
+  const active = entries.filter((e) => !e.obsolete);
+  const obsolete = entries.filter((e) => e.obsolete);
+
+  for (const entry of active) {
+    for (const loc of entry.locations) {
+      lines.push(`#: ${loc}`);
+    }
+    lines.push(`#. hash:${entry.hash}`);
+    lines.push(`msgid ${quoteString(entry.msgid)}`);
+    lines.push(`msgstr ${quoteString(entry.msgstr)}`);
+    lines.push("");
+  }
+
+  if (obsolete.length > 0) {
+    lines.push("# Obsolete entries");
+    lines.push("");
+    for (const entry of obsolete) {
+      lines.push(`#~ msgid ${quoteString(entry.msgid)}`);
+      lines.push(`#~ msgstr ${quoteString(entry.msgstr)}`);
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Merge extracted messages with existing catalog.
+ * - New msgid → add with empty msgstr
+ * - Existing msgid → keep msgstr, update locations
+ * - Removed msgid → mark obsolete (don't delete)
+ */
+export function mergeCatalog(
+  existing: CatalogEntry[],
+  extracted: Map<string, Set<string>>,
+): CatalogEntry[] {
+  const existingMap = new Map<string, CatalogEntry>();
+  for (const entry of existing) {
+    existingMap.set(entry.msgid, entry);
+  }
+
+  const result: CatalogEntry[] = [];
+  const seen = new Set<string>();
+
+  // Process all extracted messages
+  for (const [msgid, locations] of extracted) {
+    seen.add(msgid);
+    const prev = existingMap.get(msgid);
+
+    result.push({
+      msgid,
+      msgstr: prev?.msgstr ?? "",
+      locations: [...locations].sort(),
+      hash: hashMsgid(msgid),
+      obsolete: false,
+    });
+  }
+
+  // Mark removed entries as obsolete (keep their translations)
+  for (const entry of existing) {
+    if (!seen.has(entry.msgid) && !entry.obsolete && entry.msgstr) {
+      result.push({
+        ...entry,
+        obsolete: true,
+        locations: [],
+      });
+    }
+  }
+
+  return result;
+}
+
+function extractQuoted(s: string): string {
+  const trimmed = s.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed
+      .slice(1, -1)
+      .replace(/\\n/g, "\n")
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, "\\");
+  }
+  return trimmed;
+}
+
+function quoteString(s: string): string {
+  const escaped = s
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, "\\n");
+  return `"${escaped}"`;
+}

package/src/i18n/compile.ts

@@ -0,0 +1,37 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { parsePo } from "./catalog";
+
+/**
+ * Compile a .po catalog to a runtime JSON object.
+ * Only includes non-obsolete entries with non-empty msgstr.
+ * Output: { "Original text": "Translation", ... }
+ */
+export function compileCatalog(poPath: string): Record<string, string> {
+  const content = readFileSync(poPath, "utf-8");
+  const entries = parsePo(content);
+  const result: Record<string, string> = {};
+
+  for (const entry of entries) {
+    if (!entry.obsolete && entry.msgstr) {
+      result[entry.msgid] = entry.msgstr;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Compile all .po files in localesDir to .json files in outDir.
+ * Used by dev watch when .po files change.
+ */
+export function compileAllCatalogs(localesDir: string, outDir: string): void {
+  mkdirSync(outDir, { recursive: true });
+
+  for (const file of readdirSync(localesDir)) {
+    if (!file.endsWith(".po")) continue;
+    const locale = file.replace(".po", "");
+    const compiled = compileCatalog(join(localesDir, file));
+    writeFileSync(join(outDir, `${locale}.json`), JSON.stringify(compiled));
+  }
+}

package/src/i18n/index.ts

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { mergeCatalog, parsePo, writePo } from "./catalog";
+import { compileCatalog } from "./compile";
+
+export { i18nExtractPlugin } from "./plugin";
+
+export interface TranslationsConfig {
+  locales: string[];
+  sourceLocale: string;
+}
+
+/**
+ * Read translations config from package.json "arc.translations" field.
+ * Returns null if no config found.
+ */
+export function readTranslationsConfig(
+  rootDir: string,
+): TranslationsConfig | null {
+  const pkgPath = join(rootDir, "package.json");
+  if (!existsSync(pkgPath)) return null;
+
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const config = pkg.arc?.translations;
+  if (!config?.locales?.length) return null;
+
+  return {
+    locales: config.locales,
+    sourceLocale: config.sourceLocale ?? config.locales[0],
+  };
+}
+
+/**
+ * Finalize translations after Bun.build completes.
+ * Takes the collector populated by the i18n extract plugin,
+ * merges with existing .po catalogs, and compiles to .json.
+ *
+ * @param rootDir - project root (where locales/ lives)
+ * @param outDir - build output dir (where .json goes, e.g. .arc/platform)
+ * @param collector - Map<msgid, Set<location>> from plugin
+ */
+export async function finalizeTranslations(
+  rootDir: string,
+  outDir: string,
+  collector: Map<string, Set<string>>,
+) {
+  const config = readTranslationsConfig(rootDir);
+  if (!config || collector.size === 0) return;
+
+  const localesJsonDir = join(outDir, "locales");
+  mkdirSync(localesJsonDir, { recursive: true });
+
+  console.log(
+    `  Extracted ${collector.size} translatable string(s) for ${config.locales.length} locale(s)`,
+  );
+
+  for (const locale of config.locales) {
+    const poPath = join(rootDir, "locales", `${locale}.po`);
+
+    // Ensure locales dir exists
+    mkdirSync(dirname(poPath), { recursive: true });
+
+    // Merge extracted messages with existing catalog
+    const existing = existsSync(poPath)
+      ? parsePo(readFileSync(poPath, "utf-8"))
+      : [];
+    const merged = mergeCatalog(existing, collector);
+    writeFileSync(poPath, writePo(merged));
+
+    // Compile .po → .json for runtime
+    const compiled = compileCatalog(poPath);
+    writeFileSync(
+      join(localesJsonDir, `${locale}.json`),
+      JSON.stringify(compiled),
+    );
+  }
+}

package/src/i18n/plugin.ts

@@ -0,0 +1,55 @@
+import type { BunPlugin } from "bun";
+
+/**
+ * Bun plugin that extracts translatable strings from <Trans> and t`` during bundling.
+ * Does NOT transform code — returns undefined so Bun processes files normally.
+ * Collects messages as a side-effect into the provided collector map.
+ *
+ * collector: Map<msgid, Set<location>>
+ *   where location = "relative/path/to/file.tsx:lineNumber"
+ */
+export function i18nExtractPlugin(
+  collector: Map<string, Set<string>>,
+  rootDir: string,
+): BunPlugin {
+  return {
+    name: "arc-i18n-extract",
+    setup(build) {
+      build.onLoad({ filter: /\.tsx?$/ }, async (args) => {
+        const source = await Bun.file(args.path).text();
+
+        // Compute relative path for location comments
+        const relPath = args.path.startsWith(rootDir)
+          ? args.path.slice(rootDir.length + 1)
+          : args.path;
+
+        // <Trans>static text</Trans> — single-line and multi-line
+        const transRegex = /<Trans>\s*([^<{]+?)\s*<\/Trans>/g;
+        for (const match of source.matchAll(transRegex)) {
+          const msgid = match[1].trim();
+          if (!msgid) continue;
+          const line =
+            source.substring(0, match.index).split("\n").length;
+          const loc = `${relPath}:${line}`;
+          if (!collector.has(msgid)) collector.set(msgid, new Set());
+          collector.get(msgid)!.add(loc);
+        }
+
+        // t`text` — tagged template literal (no interpolation)
+        const tRegex = /\bt`([^`]+)`/g;
+        for (const match of source.matchAll(tRegex)) {
+          const msgid = match[1];
+          if (!msgid) continue;
+          const line =
+            source.substring(0, match.index).split("\n").length;
+          const loc = `${relPath}:${line}`;
+          if (!collector.has(msgid)) collector.set(msgid, new Set());
+          collector.get(msgid)!.add(loc);
+        }
+
+        // Don't transform — let Bun process the file normally
+        return undefined;
+      });
+    },
+  };
+}

package/src/index.ts

@@ -1,8 +1,11 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 import { Command } from "commander";
 import { build } from "./commands/build";
 import { dev } from "./commands/dev";
+import { platformBuild } from "./commands/platform-build";
+import { platformDev } from "./commands/platform-dev";
+import { platformStart } from "./commands/platform-start";
 
 // Create the program
 const program = new Command();
@@ -21,6 +24,26 @@ program
   .description("Build all clients and declarations")
   .action(build);
 
+// Platform subcommands
+const platform = program
+  .command("platform")
+  .description("Platform commands — run full stack (server + UI)");
+
+platform
+  .command("dev")
+  .description("Start platform in dev mode (Bun server + Vite HMR)")
+  .action(platformDev);
+
+platform
+  .command("build")
+  .description("Build platform for production")
+  .action(platformBuild);
+
+platform
+  .command("start")
+  .description("Start platform in production mode (requires prior build)")
+  .action(platformStart);
+
 // Parse command line arguments
 program.parse(process.argv);