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

package/src/commands/migrate-check.ts

@@ -37,7 +37,7 @@
  *                    `migrate` can take it over.
  *
  * Beside `state` it carries `exitCode`, `chain`, `applied`, `pending`,
- * `unknown`, `legacy` and `adoptable`.
+ * `unknown`, `legacy`, `legacyMissing` and `adoptable`.
  */
 
 import { createHash } from "node:crypto";
@@ -64,6 +64,11 @@ export type MigrateCheckResult = {
   legacy: string[];
   /** Length of the pre-1.0 chain (0 when this checkout ships none). */
   legacyChainLength: number;
+  /**
+   * Pre-1.0 migrations the database has not run, by tag, in chain
+   * order — empty unless it ran some of them.
+   */
+  legacyMissing: string[];
   /**
    * The database ran the whole pre-1.0 chain and not the baseline:
    * `migrate` records the baseline as applied without running it.
@@ -74,11 +79,11 @@ export type MigrateCheckResult = {
 /** The pre-1.0 chain's tags and hashes, if this checkout ships them. */
 export function readLegacyChain(
   migrationsDir: string
-): Array<{ tag: string; hash: string }> {
+): Array<{ tag: string; hash: string; alternates?: string[] }> {
   const file = path.join(migrationsDir, "legacy-chain.json");
   if (!existsSync(file)) return [];
   const parsed = JSON.parse(readFileSync(file, "utf8")) as {
-    entries?: Array<{ tag: string; hash: string }>;
+    entries?: Array<{ tag: string; hash: string; alternates?: string[] }>;
   };
   return parsed.entries ?? [];
 }
@@ -118,7 +123,13 @@ export async function migrateCheck(
   }
 
   const legacyChain = readLegacyChain(migrationsDir);
-  const legacyByHash = new Map(legacyChain.map((e) => [e.hash, e.tag]));
+  // A migration can be recorded under more than one hash: npm's
+  // 1.0.0-beta.6 shipped different bytes for three of them.
+  const legacyByHash = new Map(
+    legacyChain.flatMap((e) =>
+      [e.hash, ...(e.alternates ?? [])].map((h) => [h, e.tag] as const)
+    )
+  );
 
   const appliedHashes = new Set(rows.map((r) => r.hash));
   const applied: string[] = [];
@@ -144,6 +155,10 @@ export async function migrateCheck(
     unmanaged: tableMissing || appliedHashes.size === 0,
     legacy,
     legacyChainLength: legacyChain.length,
+    legacyMissing:
+      legacy.length > 0
+        ? legacyChain.map((e) => e.tag).filter((t) => !legacy.includes(t))
+        : [],
     adoptable:
       legacyChain.length > 0 &&
       legacy.length === legacyChain.length &&
@@ -185,12 +200,8 @@ export function formatMigrateCheck(
         `already there), then applies what follows. Tables the old chain ` +
         `created that the framework no longer owns are left untouched.`
     );
-  } else if (r.legacy.length > 0 && r.legacy.length < r.legacyChainLength) {
-    lines.push(
-      `✗ This database ran ${r.legacy.length} of the ${r.legacyChainLength} ` +
-        `pre-1.0 migrations. Finish that chain with @intelligo-dev/core ` +
-        `1.0.0-beta.7 (\`intelligo migrate\`) before upgrading.`
-    );
+  } else if (isPartialLegacy(r)) {
+    lines.push(`✗ ${partialLegacyMessage(r)}`);
   }
 
   if (r.unknown.length > 0) {
@@ -221,6 +232,35 @@ export function isPartialLegacy(r: MigrateCheckResult): boolean {
   return r.legacy.length > 0 && r.legacy.length < r.legacyChainLength;
 }
 
+/**
+ * The last pre-1.0 migration any published `@intelligo-dev/core`
+ * carries: 1.0.0-beta.6 shipped the chain through it, and the versions
+ * that carried the rest were never published.
+ */
+export const LAST_PUBLISHED_LEGACY_TAG = "0042_sessions_active_organization_id";
+
+/**
+ * Why a partial pre-1.0 chain is refused and where the way forward is
+ * written down. No published version finishes the chain, so the
+ * message names what is missing and points at the README's options
+ * instead of at a version to install.
+ */
+export function partialLegacyMessage(r: MigrateCheckResult): string {
+  const shown = r.legacyMissing.slice(0, 6);
+  const more = r.legacyMissing.length - shown.length;
+  return (
+    `This database ran ${r.legacy.length} of the ${r.legacyChainLength} ` +
+    `pre-1.0 migrations; it has not run ${shown.join(", ")}` +
+    `${more > 0 ? ` and ${more} more` : ""}. No published ` +
+    `@intelligo-dev/core finishes that chain: 1.0.0-beta.6 ships it ` +
+    `through ${LAST_PUBLISHED_LEGACY_TAG}, and the versions that carried ` +
+    `the rest never reached npm. Apply the missing migrations' SQL from ` +
+    `your own copy of it, or bring the schema to the baseline and record ` +
+    `it as applied — see "Databases from before 1.0" in README.md in ` +
+    `@intelligo-dev/core's src/db/migrations.`
+  );
+}
+
 export type MigrateState =
   "up_to_date" | "pending" | "fresh" | "ahead" | "unmanaged" | "legacy";
 
@@ -252,6 +292,7 @@ export function formatMigrateCheckJson(
     pending: r.pending,
     unknown: r.unknown,
     legacy: r.legacy,
+    legacyMissing: r.legacyMissing,
     adoptable: r.adoptable,
   });
 }

package/src/commands/migrate.ts

@@ -34,6 +34,7 @@ import {
   hashMigration,
   isPartialLegacy,
   migrateCheck,
+  partialLegacyMessage,
   type MigrateCheckResult,
 } from "./migrate-check.js";
 
@@ -68,14 +69,7 @@ export function decideApply(
   }
 
   if (isPartialLegacy(check)) {
-    return {
-      action: "refuse",
-      reason:
-        `This database ran ${check.legacy.length} of the ` +
-        `${check.legacyChainLength} pre-1.0 migrations. Finish that chain ` +
-        `with @intelligo-dev/core 1.0.0-beta.7 (\`intelligo migrate\`) ` +
-        `before upgrading.`,
-    };
+    return { action: "refuse", reason: partialLegacyMessage(check) };
   }
 
   if (check.adoptable) {

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)
+          )
+        ),
+      }),
+  };
+}