synthesisui 0.16.368 → 0.16.369

package/dist/commands/mcp.js

@@ -201,6 +201,24 @@ const TOOLS = [
             required: ["skill"],
         },
     },
+    {
+        name: "apply_upgrade",
+        description: "The optimisation this system can write on its OWN, and the one question to ask before writing it. Call it with { slug } to GET the question - it comes back composed, with their numbers in it, and you deliver it as it is rather than rephrasing it. Only after they say yes, call again with { slug, confirmed: true }. What it writes never adds a word they did not write and never moves a value they chose: a literal only becomes a reference when it resolves to the same value. Everything that would need a NAME from them stays out and comes back counted, so you can say what is still waiting. Do NOT call this with confirmed:true off your own judgement - the whole point of the question is that the answer is theirs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "The system's slug, as the import printed it.",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "false or omitted: returns the question and the numbers, writes nothing. true: applies it - only after they answered yes in their own words.",
+                },
+            },
+            required: ["slug"],
+        },
+    },
     {
         name: "recipe_vocabulary",
         description: "What a recipe CAN hold: every state that compiles, every preview form, the floor per kind, and the rules a media region needs. Call this BEFORE writing a recipe, not after - the reader that skipped it sent a `dark:` inside a variant and a state the compiler cannot spell, and both were dropped in silence. Served from the catalogue, so it grows as the contract grows.",
@@ -603,6 +621,54 @@ async function listComponents(root) {
  * sumário; com, UM capítulo. O corpo inteiro nunca viaja - a dieta de contexto
  * é servida por construção.
  */
+/**
+ * A OTIMIZAÇÃO QUE UMA RESPOSTA "SIM" ESCREVE - e a pergunta que a precede, composta na plataforma.
+ *
+ * O QUE O CLIENTE GANHA: ele acaba de importar e o agente lhe faz UMA pergunta ali mesmo, em vez de
+ * lhe entregar um link para uma tela com quarenta e seis decisões enfileiradas. Ele responde, e o
+ * sistema é otimizado na mesma conversa.
+ *
+ * A PERGUNTA NÃO É COMPOSTA AQUI NEM PELO AGENTE, e essa é a decisão que faz o texto sobreviver: o
+ * agente escreve bem e escreve DIFERENTE a cada execução, e uma pergunta que muda de forma a cada
+ * vez é uma paráfrase e não uma pergunta do produto. Foi assim que dois fechamentos consecutivos
+ * afirmaram que 198 declarações não chegaram a receita nenhuma quando 22 utilities dele já estavam
+ * no sistema - o resumo dropou exatamente a metade que tinha acabado de entrar. Então o texto vem
+ * pronto de `askToUpgrade`, com os números da medição dentro dele.
+ *
+ * DOIS PASSOS DE PROPÓSITO. Sem `confirmed` nada é escrito: é o que impede a jornada de pular a
+ * pergunta, que é a única coisa nela que pertence à pessoa.
+ */
+async function applyUpgrade(slug, confirmed) {
+    const answer = await askPlatform(`/api/registry/ds/${encodeURIComponent(slug)}/upgrade`, confirmed ? "POST" : "GET");
+    if (!answer.ok)
+        return answer.because;
+    const body = answer.body;
+    if (body.error)
+        return `${body.error}${body.message ? `: ${body.message}` : ""}`;
+    if (!confirmed) {
+        if (!body.ask)
+            return "Nothing here is safe to apply on its own - ask them nothing, and say the system is already on its own names.";
+        return [
+            "ASK THEM THIS, and deliver it as it is - it is composed here so the numbers cannot drift:",
+            "",
+            body.ask,
+            "",
+            `Then, and only then: call apply_upgrade again with { slug: "${slug}", confirmed: true }. If they say no, say what they are choosing - the system stays exactly as their code has it, and the optimisation waits on a button.`,
+        ].join("\n");
+    }
+    if (body.applied === false)
+        return body.message ?? "Nothing was applied.";
+    return [
+        `Done - v${body.version} published.`,
+        `${body.repointed ?? 0} literal${body.repointed === 1 ? "" : "s"} now follow their own tokens, and ${body.named ?? 0} value${body.named === 1 ? "" : "s"} became a named token.`,
+        body.waiting
+            ? `${body.waiting} decision${body.waiting === 1 ? "" : "s"} still need a word only they have - say the number, and that those wait on their own screen.`
+            : "",
+        "The version they had before is published and frozen, so going back is one click.",
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
 async function playbook(skill, section) {
     const answer = await askCatalogue("playbook", undefined, section ? { skill, section } : { skill });
     if (!answer.ok)
@@ -993,6 +1059,45 @@ cli) {
         }
     })();
 }
+/**
+ * UMA ROTA DA PLATAFORMA QUE NÃO É O CATÁLOGO, com a mesma sessão do device-login.
+ *
+ * `askCatalogue` monta `/api/catalogue?want=…` na própria assinatura, o que é certo para o que É
+ * catálogo - e a otimização não é: ela ESCREVE no sistema dele, e uma escrita atrás de um `?want=`
+ * leria como leitura. Então a única coisa compartilhada é o que deve ser: o token e o host.
+ *
+ * O MODO DE FALHA É DITO EM VOZ ALTA, nas três formas em que ele acontece - sem sessão, resposta de
+ * erro, sem rede. Um `catch` que devolve silêncio faria o agente concluir que não havia nada a
+ * fazer, e o cliente perderia a otimização sem nunca saber que ela existia.
+ */
+async function askPlatform(path, method) {
+    const token = await readToken();
+    if (!token)
+        return {
+            ok: false,
+            because: "Not signed in, so the platform could not answer. Run `synthesisui login` in the terminal and call this again.",
+        };
+    try {
+        const res = await fetch(`${resolveRegistry()}${path}`, {
+            method,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return {
+                ok: false,
+                because: res.status === 404
+                    ? "No system by that slug on this account - check the slug the import printed."
+                    : `The platform answered ${res.status}. ${res.status === 401 ? "Run `synthesisui login` and try again." : "Nothing was written."}`,
+            };
+        return { ok: true, body: await res.json() };
+    }
+    catch {
+        return {
+            ok: false,
+            because: "No network, so the platform could not answer. Nothing was written - say that, and offer to try again rather than describing what would have happened.",
+        };
+    }
+}
 async function askCatalogue(want, post, 
 /** Parâmetros extras do GET (ex.: o playbook e o capítulo pedidos). */
 query) {
@@ -1547,6 +1652,9 @@ cli) {
             const section = args?.section ? String(args.section) : undefined;
             return fromContract(await playbook(skill, section));
         }
+        case "apply_upgrade": {
+            return fromContract(await applyUpgrade(String(args?.slug ?? ""), args?.confirmed === true));
+        }
         case "recipe_vocabulary":
             return fromContract(await recipeVocabulary());
         case "validate_recipe": {

package/package.json

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