synthesisui 0.16.167 → 0.16.170

package/dist/commands/add.js

@@ -136,6 +136,7 @@ export async function add(slug, opts) {
         version: payload.version,
         registry: base,
         fetchedAt: new Date().toISOString(),
+        ...(opts.cli ? { cli: opts.cli } : {}),
         ...(scope ? { scope } : {}),
         ...(usage.length > 0 ? { usage } : {}),
     };

package/dist/commands/align.js

@@ -94,6 +94,22 @@ opts = {}) {
             says: `${events.length} checked write${events.length === 1 ? "" : "s"} recorded here and not sent - the platform is scoring this repo on older evidence.`,
             run: "npx synthesisui sync",
         });
+    /**
+     * O DÉCIMO ESTADO: os ARQUIVOS deste install foram escritos por um CLI anterior.
+     *
+     * Os nove primeiros nunca cobriram isto, e ele é sorrateiro: o sistema pode estar na ÚLTIMA versão
+     * do DS e ter uma pasta escrita por um CLI de dez versões atrás. Em 07/08 foi a doutrina - o `add`
+     * de hoje escreve `doctrine.json` e o de ontem materializava dois `.md` -, e o `upgrade` sai sem
+     * fazer nada quando não há gap de versão, então nenhum comando alcançava aquele estado.
+     *
+     * O `connect` conserta na hora (ver `refreshInstall`), e esta linha existe para quem ainda não
+     * rodou: a verificação de abertura é o único lugar que fala sem ser perguntado.
+     */
+    if (cli && lock.cli && lock.cli !== cli)
+        out.push({
+            says: `the files under _synthesisui/ds/${lock.slug} were written by CLI ${lock.cli} and you are running ${cli} - the design system's version has not changed, but what this CLI writes into that folder has.`,
+            run: "npx synthesisui connect",
+        });
     if (cli && lock.version == null)
         out.push({
             says: `"${lock.slug}" has no version recorded, so nothing can tell whether the CSS in this repo is the one the platform publishes.`,

package/dist/commands/connect.js

@@ -1,10 +1,11 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { wireAgent } from "../agent-wiring.js";
 import { blockHomes, syncClaudeMd } from "../claude-md.js";
 import { body, paint, section, snippet } from "../output.js";
 import { IMPORT_SKILL, IMPORT_SKILL_PATH } from "../skill-import.js";
 import { INIT_SKILL, INIT_SKILL_PATH } from "../skill-init.js";
+import { add } from "./add.js";
 import { ci } from "./ci.js";
 import { MCP_TOOL_COUNT } from "./mcp.js";
 /**
@@ -28,16 +29,82 @@ import { MCP_TOOL_COUNT } from "./mcp.js";
  * um cliente que rodou `connect` há um mês não sabe que o nome mudou.
  */
 const LEGACY_SKILLS = ["import-design-system"];
+/**
+ * OS ARQUIVOS DO INSTALL, PÔSTOS EM DIA COM ESTE CLI.
+ *
+ * A fiação era reconciliada (hook, MCP, CLAUDE.md, skills) e os arquivos do sistema instalado não.
+ * Medido em 07/08: o `add` de hoje serve a doutrina por ferramenta e escreve `doctrine.json`; o de
+ * ontem materializava `rules.md` e `philosophy.md`. Um repo que rodou `connect` e `sync` ficava com os
+ * dois `.md` velhos, sem `doctrine.json`, sem escopo no `.lock` - e o `upgrade` SAI SEM FAZER NADA
+ * quando não há gap de versão, então nenhum dos seis comandos alcançava esse estado.
+ *
+ * O `connect` é o lugar honesto: é o comando que a pessoa roda quando atualiza o CLI, e a pergunta que
+ * ela já está fazendo é "me põe em dia".
+ *
+ * REMATERIALIZA A MESMA VERSÃO, nunca uma nova: `add` com a `version` que o `.lock` pina. Subir de
+ * versão é decisão dela e continua sendo o `upgrade`.
+ *
+ * SILENCIOSO QUANDO JÁ ESTÁ EM DIA, e sem rede não faz nada - um `connect` que falha por estar num
+ * avião seria pior que a defasagem que ele conserta.
+ */
+async function refreshInstall(root, cli, registry) {
+    const dsDir = join(root, "_synthesisui", "ds");
+    const names = await readdir(dsDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of names) {
+        if (!entry.isDirectory())
+            continue;
+        const raw = await readFile(join(dsDir, entry.name, ".lock"), "utf8").catch(() => null);
+        if (!raw)
+            continue;
+        let lock;
+        try {
+            lock = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        /** Um DS adotado é descrito aqui e pertencido em outro lugar - não há o que rematerializar. */
+        if (!lock.slug || lock.adopted || typeof lock.version !== "number")
+            continue;
+        if (lock.cli === cli)
+            continue;
+        const done = await add(lock.slug, {
+            ...(registry ? { registry } : {}),
+            dir: root,
+            version: lock.version,
+            setupHints: false,
+            cli,
+        }).then(() => true, () => false);
+        if (!done)
+            return null;
+        return { slug: lock.slug, ...(lock.cli ? { was: lock.cli } : {}) };
+    }
+    return null;
+}
 export async function connect(opts) {
     const root = opts.dir ?? process.cwd();
     // Both unless one is explicitly turned off - somebody who says `--no-hook`
     // means it, and somebody who says nothing wants the thing to work.
     const want = { hook: opts.hook !== false, mcp: opts.mcp !== false };
+    /**
+     * OS ARQUIVOS DO INSTALL ANTES DA FIAÇÃO: o `add` reescreve o `CLAUDE.md` por dentro, e o
+     * `syncClaudeMd` abaixo tem que ser o último a falar sobre ele.
+     */
+    const refreshed = await refreshInstall(root, opts.version, opts.registry).catch(() => null);
     const wired = await wireAgent(root, opts.version, want);
     // The block reads the settings we just wrote, so it must be regenerated
     // after them, not before.
     await syncClaudeMd(root);
     console.log(section("Connected"));
+    /**
+     * O QUE ESTE CLI REESCREVEU NA PASTA DO SISTEMA - dito primeiro, porque é o que a pessoa não sabia
+     * que estava devendo. Ela rodou `connect` para atualizar a fiação; os arquivos do install estarem
+     * velhos era invisível, e o `upgrade` não alcançava (ver `refreshInstall`).
+     */
+    if (refreshed)
+        console.log(body(`✓ _synthesisui/ds/${refreshed.slug}/  rewritten by this CLI${refreshed.was
+            ? ` - it was written by ${refreshed.was}`
+            : " - it carried no CLI version, so it predates this"}`));
     if (want.hook) {
         console.log(body(wired.hook === "added"
             ? "✓ .claude/settings.json  the check now runs after every write"

package/dist/commands/import.js

@@ -982,10 +982,11 @@ export async function takeCensus(root, opts) {
      * percorrer o repo inteiro de novo por um dado que este laço já tem na mão. Ver `reachability.ts`.
      */
     const edges = new Map();
-    const aliases = [];
+    /** Por raiz: `@/` é uma pasta diferente em cada app - ver `reachabilityOf`. */
+    const graphRoots = [];
     for (const u of opts?.usage ?? []) {
         const uInternal = await internalSpecifiers(u.path);
-        aliases.push(...(await aliasesOf(u.path)));
+        graphRoots.push({ path: u.path, aliases: await aliasesOf(u.path) });
         for await (const file of walk(u.path)) {
             const src = await readFile(file, "utf8").catch(() => "");
             if (!src)
@@ -1231,7 +1232,7 @@ export async function takeCensus(root, opts) {
      * O GRAFO SÓ FECHA DEPOIS QUE TODOS OS ARQUIVOS FORAM VISTOS: um especificador só resolve para um
      * arquivo que já esteja na lista, então isto não pode rodar dentro do laço que a preenche.
      */
-    const reachability = edges.size > 0 ? await reachabilityOf({ edges, aliases }) : null;
+    const reachability = edges.size > 0 ? await reachabilityOf({ edges, roots: graphRoots }) : null;
     const coverage = summarizeCoverage(shapes, defined.length || componentFiles, Object.keys(looks).length, Object.values(looks).reduce((n, look) => n +
         Object.keys(look.base).length +
         Object.keys(look.dark ?? {}).length +

package/dist/commands/upgrade.js

@@ -125,7 +125,12 @@ export async function upgrade(slug, opts) {
     }
     // 1. re-materialize the artifacts (v<latest>/ + root re-exports + .lock);
     //    setup hints suppressed - an upgrade means the app is already wired.
-    await add(slug, { registry: opts.registry, dir: root, setupHints: false });
+    await add(slug, {
+        registry: opts.registry,
+        dir: root,
+        setupHints: false,
+        ...(opts.cli ? { cli: opts.cli } : {}),
+    });
     // 2. regenerate YOUR materialized components (the ones `component` wrote)
     const config = await readProjectConfig(root);
     const regenerated = [];

package/dist/doctor/reachability.js

@@ -215,13 +215,17 @@ export async function reachabilityOf(input) {
         !/\/[a-z.-]+\.config\.[jt]sx?$/.test(f)));
     const graph = new Map();
     let unresolved = 0;
+    /** A raiz MAIS LONGA que contém o arquivo - um app dentro de outro resolve pelo mais específico. */
+    const rootOf = (file) => input.roots
+        .filter((r) => file.startsWith(`${r.path}/`))
+        .sort((a, b) => b.path.length - a.path.length)[0]?.aliases ?? [];
     for (const [file, specs] of input.edges) {
         if (!known.has(file))
             continue;
+        const aliases = rootOf(file);
         const out = [];
         for (const spec of specs) {
-            const mine = spec.startsWith(".") ||
-                input.aliases.some((a) => spec.startsWith(a.prefix));
+            const mine = spec.startsWith(".") || aliases.some((a) => spec.startsWith(a.prefix));
             /**
              * Pacote de terceiro não é aresta deste repo. Mas um apelido LOCAL que nenhum alias casa é uma
              * aresta PERDIDA - e era descartado aqui em silêncio, o que subia o número de mortos sem a
@@ -232,7 +236,7 @@ export async function reachabilityOf(input) {
                     unresolved += 1;
                 continue;
             }
-            const hit = await toFile(known, file, spec, input.aliases, isFile);
+            const hit = await toFile(known, file, spec, aliases, isFile);
             if (hit)
                 out.push(hit);
             /**
@@ -256,11 +260,21 @@ export async function reachabilityOf(input) {
             if (!seen.has(next))
                 queue.push(next);
     }
+    /**
+     * ALCANÇADOS DENTRO DO UNIVERSO, e não `seen.size`.
+     *
+     * A travessia atravessa para fora: um alias que aponta para outro pacote do monorepo resolve no
+     * disco e entra em `seen`, mas não está em `known` - o universo é o que foi varrido. Contar
+     * `seen.size` inflava `reached` com nós de fora e fazia `reached + unreached` não fechar com
+     * `files`, o que produziu um "19% morto" que na verdade é 41% (dono, 07/08). Um número que não
+     * fecha com a própria soma é um número que ninguém pode checar.
+     */
+    const unreached = [...known].filter((f) => !seen.has(f)).sort();
     return {
         entries: entries.length,
         files: known.size,
-        reached: seen.size,
-        unreached: [...known].filter((f) => !seen.has(f)).sort(),
+        reached: known.size - unreached.length,
+        unreached,
         unresolved,
     };
 }

package/dist/index.js

@@ -241,6 +241,7 @@ async function main() {
         case "connect":
             await connect({
                 dir,
+                ...(registry ? { registry } : {}),
                 version: CLI_VERSION,
                 hook: flags.hook !== false,
                 mcp: flags.mcp !== false,
@@ -379,7 +380,7 @@ async function main() {
                     return;
                 }
             }
-            await add(slug, { registry, dir, version });
+            await add(slug, { registry, dir, version, cli: CLI_VERSION });
             break;
         }
         case "login":
@@ -512,6 +513,7 @@ async function main() {
             await upgrade(slug, {
                 registry,
                 dir,
+                cli: CLI_VERSION,
                 force: flags.force === true,
                 from: typeof flags.from === "string" ? Number(flags.from) : undefined,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.167",
+  "version": "0.16.170",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {