@intelligo-dev/cli 1.0.0-beta.13 → 1.0.0-beta.14

package/src/commands/sync-messages.ts

@@ -0,0 +1,114 @@
+/**
+ * Message files under `intelligo sync`: the registry's keys an app's
+ * copy lacks, the merge that keeps the app's values, and the other
+ * locales checked against the app's English copy.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+export type Json = Record<string, unknown>;
+
+const isObject = (v: unknown): v is Json =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** Dotted paths of every leaf in `registry` that `app` lacks. */
+export function missingMessageKeys(
+  registry: Json,
+  app: Json,
+  prefix = ""
+): string[] {
+  return Object.entries(registry).flatMap(([key, value]) => {
+    const at = prefix ? `${prefix}.${key}` : key;
+    if (!(key in app)) return [at];
+    const mine = app[key];
+    return isObject(value) && isObject(mine)
+      ? missingMessageKeys(value, mine, at)
+      : [];
+  });
+}
+
+/**
+ * The registry's messages with the app's copy laid over them: every key
+ * the registry has is present, every value the app set wins, and keys
+ * only the app has (its own nav entries, product copy) are kept.
+ */
+export function mergeMessages(registry: Json, app: Json): Json {
+  const out: Json = {};
+  for (const [key, value] of Object.entries(registry)) {
+    const mine = app[key];
+    out[key] =
+      key in app
+        ? isObject(value) && isObject(mine)
+          ? mergeMessages(value, mine)
+          : mine
+        : value;
+  }
+  for (const [key, value] of Object.entries(app)) {
+    if (!(key in out)) out[key] = value;
+  }
+  return out;
+}
+
+export const isMessages = (target: string) =>
+  target.startsWith("messages/") && target.endsWith(".json");
+
+/** The locale the registry ships messages in. */
+const SOURCE_LOCALE = "en";
+
+/**
+ * The app's locales, from `locales: [...]` in i18n/routing.ts — the
+ * source locale alone when there is no such file or list.
+ */
+export function appLocales(appRoot: string): string[] {
+  const file = path.join(appRoot, "i18n", "routing.ts");
+  if (!existsSync(file)) return [SOURCE_LOCALE];
+  const list = /\blocales\s*:\s*\[([^\]]*)\]/.exec(readFileSync(file, "utf8"));
+  const locales = [...(list?.[1] ?? "").matchAll(/["'`]([^"'`]+)["'`]/g)].map(
+    (m) => m[1]!
+  );
+  return locales.length > 0 ? locales : [SOURCE_LOCALE];
+}
+
+export type LocaleEntry = {
+  item: string;
+  path: string;
+  state: "current" | "locale-behind";
+  missingKeys?: string[];
+};
+
+/**
+ * Every other locale's copy of the namespaces the registry ships,
+ * against the app's English file on disk — the merged copy, product
+ * keys included, which is what the other locales translate. A missing
+ * file lacks every key.
+ */
+export function localeEntries(
+  appRoot: string,
+  files: readonly { item: string; target: string }[]
+): LocaleEntry[] {
+  const others = appLocales(appRoot).filter((l) => l !== SOURCE_LOCALE);
+  if (others.length === 0) return [];
+  const prefix = `messages/${SOURCE_LOCALE}/`;
+  const entries: LocaleEntry[] = [];
+  for (const { item, target } of files) {
+    if (!target.startsWith(prefix) || !target.endsWith(".json")) continue;
+    const english = path.join(appRoot, target);
+    if (!existsSync(english)) continue;
+    const source = JSON.parse(readFileSync(english, "utf8")) as Json;
+    for (const locale of others) {
+      const rel = `messages/${locale}/${target.slice(prefix.length)}`;
+      const abs = path.join(appRoot, rel);
+      const missingKeys = missingMessageKeys(
+        source,
+        existsSync(abs) ? (JSON.parse(readFileSync(abs, "utf8")) as Json) : {}
+      );
+      entries.push(
+        missingKeys.length > 0
+          ? { item, path: rel, state: "locale-behind", missingKeys }
+          : { item, path: rel, state: "current" }
+      );
+    }
+  }
+  return entries;
+}

package/src/commands/sync-scaffold.ts

@@ -0,0 +1,83 @@
+/**
+ * Scaffold files a registry install replaces. `intelligo create`
+ * writes app/globals.css, the theme provider and lib/utils.ts; the
+ * design-system base and the items overwrite them, and the scaffold's
+ * record has to let go of them or `upgrade --check` reports them as
+ * the app's own edits forever.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+import { readManifest } from "../manifest.js";
+
+/** The `intelligo create` feature whose files an install may replace. */
+export const SCAFFOLD_FEATURE = "app-scaffold";
+
+/**
+ * Scaffold files the install extends in place rather than replaces:
+ * shadcn adds dependencies to package.json and style fields to
+ * components.json, and both stay the app's.
+ */
+const EDITED_IN_PLACE: ReadonlySet<string> = new Set([
+  "package.json",
+  "components.json",
+]);
+
+/**
+ * The scaffold files an install has made the registry's: a file an
+ * installed item ships, the Tailwind stylesheet once the design-system
+ * base is in (it rewrites the tokens), or any scaffold file the install
+ * changed (shadcn's own `utils`, `sonner`). Seams stay the app's, and
+ * so do the files shadcn only extends. Left in the scaffold's record,
+ * each would read `customized` in `upgrade --check` forever.
+ */
+export function scaffoldHandover(input: {
+  scaffold: readonly string[];
+  changed: ReadonlySet<string>;
+  shipped: ReadonlySet<string>;
+  seams: Readonly<Record<string, string>>;
+  css: string | null;
+}): string[] {
+  return input.scaffold.filter(
+    (file) =>
+      !(file in input.seams) &&
+      !EDITED_IN_PLACE.has(file) &&
+      (input.shipped.has(file) || file === input.css || input.changed.has(file))
+  );
+}
+
+function readIfExists(file: string): string | null {
+  return existsSync(file) ? readFileSync(file, "utf8") : null;
+}
+
+/**
+ * The scaffold's recorded files as they are before an install, and
+ * afterwards the ones the install made the registry's.
+ */
+export function snapshotScaffold(appRoot: string): {
+  handedOver: (input: {
+    shipped: ReadonlySet<string>;
+    seams: Readonly<Record<string, string>>;
+    css: string | null;
+  }) => string[];
+} {
+  const scaffold = (
+    readManifest(appRoot)?.features[SCAFFOLD_FEATURE]?.files ?? []
+  ).map((f) => f.path);
+  const before = new Map(
+    scaffold.map((f) => [f, readIfExists(path.join(appRoot, f))])
+  );
+  return {
+    handedOver: (input) =>
+      scaffoldHandover({
+        ...input,
+        scaffold,
+        changed: new Set(
+          scaffold.filter(
+            (f) => readIfExists(path.join(appRoot, f)) !== before.get(f)
+          )
+        ),
+      }),
+  };
+}