create-rubrica 0.1.0

package/dist/index.js

@@ -0,0 +1,1584 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { intro as intro3 } from "@clack/prompts";
+
+// src/commands/create.ts
+import { outro, text as text2, select as select2, multiselect, confirm } from "@clack/prompts";
+import * as nodeFsPromises9 from "fs/promises";
+
+// src/prompts/identityPrompt.ts
+import { text, select, isCancel, cancel } from "@clack/prompts";
+function assertNotCancelled(value) {
+  if (isCancel(value)) {
+    cancel("Opera\xE7\xE3o cancelada.");
+    throw new Error("Prompt cancelado pelo usu\xE1rio.");
+  }
+}
+async function identityPrompt(defaults) {
+  const siteName = await text({
+    message: "Nome do site (aparece no t\xEDtulo do browser e SEO)",
+    initialValue: defaults?.siteName ?? ""
+  });
+  assertNotCancelled(siteName);
+  const siteUrl = await text({
+    message: "URL do site (sem barra no final)",
+    initialValue: defaults?.siteUrl ?? "",
+    validate: (v) => {
+      if (!v.startsWith("http://") && !v.startsWith("https://")) {
+        return "A URL deve come\xE7ar com http:// ou https://";
+      }
+    }
+  });
+  assertNotCancelled(siteUrl);
+  const siteDescription = await text({
+    message: "Descri\xE7\xE3o curta (SEO e Open Graph)",
+    initialValue: defaults?.siteDescription ?? ""
+  });
+  assertNotCancelled(siteDescription);
+  const authorName = await text({
+    message: "Seu nome (para RSS e meta author)",
+    initialValue: defaults?.authorName ?? ""
+  });
+  assertNotCancelled(authorName);
+  const authorEmail = await text({
+    message: "Seu email (para RSS \u2014 n\xE3o aparece publicamente)",
+    initialValue: defaults?.authorEmail ?? "",
+    validate: (v) => {
+      if (!v.includes("@") || !v.includes(".")) {
+        return "Informe um email v\xE1lido (ex: contato@meusite.com)";
+      }
+    }
+  });
+  assertNotCancelled(authorEmail);
+  const twitterHandle = await text({
+    message: "Twitter/X handle (sem @, Enter para pular)",
+    initialValue: defaults?.twitterHandle ?? ""
+  });
+  assertNotCancelled(twitterHandle);
+  const lang = await select({
+    message: "Idioma padr\xE3o",
+    initialValue: defaults?.lang ?? "pt-BR",
+    options: [
+      { value: "pt-BR", label: "Portugu\xEAs (pt-BR)" },
+      { value: "en-US", label: "Ingl\xEAs (en-US)" }
+    ]
+  });
+  assertNotCancelled(lang);
+  return {
+    siteName,
+    siteUrl,
+    siteDescription,
+    authorName,
+    authorEmail,
+    twitterHandle: twitterHandle ?? "",
+    lang
+  };
+}
+
+// src/utils/download.ts
+import { writeFile, mkdtemp, rm, mkdir } from "fs/promises";
+import { execFile } from "child_process";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GITHUB_REPO = "MierzwaMatheus/rubrica";
+async function getLatestVersion() {
+  const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: { "User-Agent": "create-rubrica-cli" }
+    });
+  } catch {
+    throw new Error(
+      "Erro de rede ao consultar o GitHub. Verifique sua conex\xE3o e tente novamente."
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `N\xE3o foi poss\xEDvel obter a vers\xE3o mais recente do Rubrica (HTTP ${response.status}). Verifique sua conex\xE3o.`
+    );
+  }
+  const data = await response.json();
+  if (!data.tag_name) {
+    throw new Error(
+      "Release sem tarball encontrada no GitHub. Tente novamente mais tarde."
+    );
+  }
+  return data.tag_name;
+}
+async function downloadRelease(targetDir, version) {
+  const tarballUrl = `https://api.github.com/repos/${GITHUB_REPO}/tarball/${version}`;
+  let response;
+  try {
+    response = await fetch(tarballUrl, {
+      headers: { "User-Agent": "create-rubrica-cli" },
+      redirect: "follow"
+    });
+  } catch {
+    throw new Error(
+      "Erro de rede ao baixar o Rubrica. Verifique sua conex\xE3o e tente novamente."
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `N\xE3o foi poss\xEDvel baixar o Rubrica (HTTP ${response.status}).`
+    );
+  }
+  if (!response.body) {
+    throw new Error("Release sem tarball encontrada. Tente novamente mais tarde.");
+  }
+  const tmpDir = await mkdtemp(join(tmpdir(), "rubrica-download-"));
+  const tmpFile = join(tmpDir, "rubrica.tar.gz");
+  try {
+    const buffer = await response.arrayBuffer();
+    await writeFile(tmpFile, Buffer.from(buffer));
+    await mkdir(targetDir, { recursive: true });
+    await execFileAsync("tar", ["-xzf", tmpFile, "--strip-components=1", "-C", targetDir]);
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// src/transforms/applyLayout.ts
+import * as nodeFsPromises from "fs/promises";
+import * as path from "path";
+var LAYOUT_FILES = {
+  sidebar: {
+    copy: ["Layout.tsx", "Sidebar.tsx"],
+    remove: ["Navbar.tsx", "Footer.tsx"]
+  },
+  topbar: {
+    copy: ["Layout.tsx", "Navbar.tsx"],
+    remove: ["Sidebar.tsx", "Footer.tsx"]
+  },
+  centered: {
+    copy: ["Layout.tsx", "Footer.tsx"],
+    remove: ["Sidebar.tsx", "Navbar.tsx"]
+  }
+};
+var defaultFs = {
+  ...nodeFsPromises,
+  exists: async (p) => {
+    try {
+      await nodeFsPromises.access(p);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+async function applyLayout(layout, options, fsModule = defaultFs) {
+  const spec = LAYOUT_FILES[layout];
+  if (!spec) {
+    throw new Error(`applyLayout: layout "${layout}" n\xE3o reconhecido.`);
+  }
+  const { projectDir, templatesDir } = options;
+  const srcDir = path.join(templatesDir, "layouts", layout);
+  const destDir = path.join(projectDir, "src", "components");
+  await fsModule.mkdir(destDir, { recursive: true });
+  for (const file of spec.copy) {
+    await fsModule.copyFile(path.join(srcDir, file), path.join(destDir, file));
+  }
+  for (const file of spec.remove) {
+    const filePath = path.join(destDir, file);
+    if (await fsModule.exists(filePath)) {
+      await fsModule.unlink(filePath);
+    }
+  }
+}
+
+// src/transforms/applyTheme.ts
+import * as nodeFsPromises2 from "fs/promises";
+
+// src/utils/hexToHsl.ts
+function hexToHsl(hex) {
+  const clean = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (!/^[0-9a-fA-F]{6}$/.test(clean)) {
+    throw new Error(`hexToHsl: valor inv\xE1lido "${hex}". Esperado hex de 6 d\xEDgitos (ex: #ff0000).`);
+  }
+  const r = parseInt(clean.slice(0, 2), 16) / 255;
+  const g = parseInt(clean.slice(2, 4), 16) / 255;
+  const b = parseInt(clean.slice(4, 6), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  const l = (max + min) / 2;
+  let s = 0;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+  }
+  let h = 0;
+  if (delta !== 0) {
+    if (max === r) h = (g - b) / delta % 6;
+    else if (max === g) h = (b - r) / delta + 2;
+    else h = (r - g) / delta + 4;
+    h = h * 60;
+    if (h < 0) h += 360;
+  }
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+
+// src/transforms/applyTheme.ts
+var PRESETS = {
+  forest: {
+    root: `  --background: 60 20% 97%;
+  --foreground: 120 8% 12%;
+  --card: 60 20% 99%;
+  --card-foreground: 120 8% 12%;
+  --popover: 60 20% 99%;
+  --popover-foreground: 120 8% 12%;
+  --primary: 150 40% 35%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 80 15% 90%;
+  --secondary-foreground: 120 8% 12%;
+  --muted: 80 15% 90%;
+  --muted-foreground: 120 5% 45%;
+  --accent: 80 15% 90%;
+  --accent-foreground: 120 8% 12%;
+  --destructive: 0 84% 60%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 80 15% 84%;
+  --input: 80 15% 84%;
+  --ring: 150 40% 35%;
+  --radius: 0.5rem;
+  --sidebar: 60 20% 95%;
+  --sidebar-foreground: 120 5% 45%;
+  --sidebar-primary: 150 40% 35%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 80 15% 90%;
+  --sidebar-accent-foreground: 120 8% 12%;
+  --sidebar-border: 80 15% 84%;
+  --sidebar-ring: 150 40% 35%;
+  --neon-purple: 150 40% 35%;
+  --neon-lime: 80 50% 40%;`,
+    dark: `  --background: 30 15% 8%;
+  --foreground: 60 15% 88%;
+  --card: 30 12% 12%;
+  --card-foreground: 60 15% 88%;
+  --popover: 30 12% 12%;
+  --popover-foreground: 60 15% 88%;
+  --primary: 150 40% 35%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 30 10% 18%;
+  --secondary-foreground: 60 15% 88%;
+  --muted: 30 10% 18%;
+  --muted-foreground: 60 8% 55%;
+  --accent: 30 10% 18%;
+  --accent-foreground: 60 15% 88%;
+  --destructive: 0 62% 50%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 30 10% 18%;
+  --input: 30 10% 18%;
+  --ring: 150 40% 35%;
+  --sidebar: 30 15% 6%;
+  --sidebar-foreground: 60 8% 55%;
+  --sidebar-primary: 150 40% 35%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 30 10% 18%;
+  --sidebar-accent-foreground: 60 15% 88%;
+  --sidebar-border: 30 10% 18%;
+  --sidebar-ring: 150 40% 35%;`
+  },
+  editorial: {
+    root: `  --background: 38 30% 96%;
+  --foreground: 24 10% 10%;
+  --card: 38 30% 99%;
+  --card-foreground: 24 10% 10%;
+  --popover: 38 30% 99%;
+  --popover-foreground: 24 10% 10%;
+  --primary: 35 90% 50%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 38 25% 90%;
+  --secondary-foreground: 24 10% 10%;
+  --muted: 38 25% 90%;
+  --muted-foreground: 24 8% 45%;
+  --accent: 38 25% 90%;
+  --accent-foreground: 24 10% 10%;
+  --destructive: 0 84% 60%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 35 20% 85%;
+  --input: 35 20% 85%;
+  --ring: 35 90% 50%;
+  --radius: 0.375rem;
+  --sidebar: 38 30% 94%;
+  --sidebar-foreground: 24 8% 45%;
+  --sidebar-primary: 35 90% 50%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 38 25% 90%;
+  --sidebar-accent-foreground: 24 10% 10%;
+  --sidebar-border: 35 20% 85%;
+  --sidebar-ring: 35 90% 50%;
+  --neon-purple: 35 90% 50%;
+  --neon-lime: 45 93% 47%;`,
+    dark: `  --background: 25 20% 8%;
+  --foreground: 38 20% 90%;
+  --card: 25 18% 12%;
+  --card-foreground: 38 20% 90%;
+  --popover: 25 18% 12%;
+  --popover-foreground: 38 20% 90%;
+  --primary: 35 90% 50%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 25 15% 18%;
+  --secondary-foreground: 38 20% 90%;
+  --muted: 25 15% 18%;
+  --muted-foreground: 35 10% 55%;
+  --accent: 25 15% 18%;
+  --accent-foreground: 38 20% 90%;
+  --destructive: 0 62% 50%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 25 15% 18%;
+  --input: 25 15% 18%;
+  --ring: 35 90% 50%;
+  --sidebar: 25 20% 6%;
+  --sidebar-foreground: 35 10% 55%;
+  --sidebar-primary: 35 90% 50%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 25 15% 18%;
+  --sidebar-accent-foreground: 38 20% 90%;
+  --sidebar-border: 25 15% 18%;
+  --sidebar-ring: 35 90% 50%;`
+  },
+  minimal: {
+    root: `  --background: 0 0% 98%;
+  --foreground: 222 47% 11%;
+  --card: 0 0% 100%;
+  --card-foreground: 222 47% 11%;
+  --popover: 0 0% 100%;
+  --popover-foreground: 222 47% 11%;
+  --primary: 220 90% 56%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 210 40% 96%;
+  --secondary-foreground: 222 47% 11%;
+  --muted: 210 40% 96%;
+  --muted-foreground: 215 16% 47%;
+  --accent: 210 40% 96%;
+  --accent-foreground: 222 47% 11%;
+  --destructive: 0 84% 60%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 214 32% 91%;
+  --input: 214 32% 91%;
+  --ring: 220 90% 56%;
+  --radius: 0.5rem;
+  --sidebar: 210 40% 98%;
+  --sidebar-foreground: 215 16% 47%;
+  --sidebar-primary: 220 90% 56%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 210 40% 96%;
+  --sidebar-accent-foreground: 222 47% 11%;
+  --sidebar-border: 214 32% 91%;
+  --sidebar-ring: 220 90% 56%;
+  --neon-purple: 220 90% 56%;
+  --neon-lime: 142 76% 36%;`,
+    dark: `  --background: 220 14% 10%;
+  --foreground: 210 40% 96%;
+  --card: 222 47% 11%;
+  --card-foreground: 210 40% 96%;
+  --popover: 222 47% 11%;
+  --popover-foreground: 210 40% 96%;
+  --primary: 220 90% 56%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 217 33% 17%;
+  --secondary-foreground: 210 40% 96%;
+  --muted: 217 33% 17%;
+  --muted-foreground: 215 20% 65%;
+  --accent: 217 33% 17%;
+  --accent-foreground: 210 40% 96%;
+  --destructive: 0 62% 50%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 217 33% 17%;
+  --input: 217 33% 17%;
+  --ring: 220 90% 56%;
+  --sidebar: 222 47% 8%;
+  --sidebar-foreground: 215 20% 65%;
+  --sidebar-primary: 220 90% 56%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 217 33% 17%;
+  --sidebar-accent-foreground: 210 40% 96%;
+  --sidebar-border: 217 33% 17%;
+  --sidebar-ring: 220 90% 56%;`
+  },
+  cyberpunk: {
+    root: `  --background: 0 0% 14.5%;
+  --foreground: 0 0% 90%;
+  --card: 0 0% 4%;
+  --card-foreground: 0 0% 90%;
+  --popover: 0 0% 4%;
+  --popover-foreground: 0 0% 90%;
+  --primary: 263 90% 66%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 215 28% 17%;
+  --secondary-foreground: 0 0% 90%;
+  --muted: 0 0% 9%;
+  --muted-foreground: 0 0% 64%;
+  --accent: 0 0% 9%;
+  --accent-foreground: 0 0% 90%;
+  --destructive: 0 84% 60%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 0 0% 15%;
+  --input: 0 0% 15%;
+  --ring: 263 90% 66%;
+  --radius: 0.5rem;
+  --sidebar: 0 0% 0%;
+  --sidebar-foreground: 0 0% 64%;
+  --sidebar-primary: 263 90% 66%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 0 0% 9%;
+  --sidebar-accent-foreground: 0 0% 90%;
+  --sidebar-border: 0 0% 15%;
+  --sidebar-ring: 263 90% 66%;
+  --neon-purple: 271 91% 65%;
+  --neon-lime: 82 85% 67%;`,
+    dark: `  --background: 0 0% 8%;
+  --foreground: 0 0% 90%;
+  --card: 0 0% 4%;
+  --card-foreground: 0 0% 90%;
+  --popover: 0 0% 4%;
+  --popover-foreground: 0 0% 90%;
+  --primary: 263 90% 66%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 215 28% 17%;
+  --secondary-foreground: 0 0% 90%;
+  --muted: 0 0% 9%;
+  --muted-foreground: 0 0% 64%;
+  --accent: 0 0% 9%;
+  --accent-foreground: 0 0% 90%;
+  --destructive: 0 84% 60%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 0 0% 15%;
+  --input: 0 0% 15%;
+  --ring: 263 90% 66%;
+  --sidebar: 0 0% 4%;
+  --sidebar-foreground: 0 0% 64%;
+  --sidebar-primary: 263 90% 66%;
+  --sidebar-primary-foreground: 0 0% 100%;
+  --sidebar-accent: 0 0% 9%;
+  --sidebar-accent-foreground: 0 0% 90%;
+  --sidebar-border: 0 0% 15%;
+  --sidebar-ring: 263 90% 66%;`
+  }
+};
+function buildCustomThemeVars(accentColor) {
+  const { h, s, l } = hexToHsl(accentColor);
+  const hsl = `${h} ${s}% ${l}%`;
+  const vars = `  --primary: ${hsl};
+  --ring: ${hsl};
+  --sidebar-primary: ${hsl};
+  --sidebar-ring: ${hsl};`;
+  return { root: vars, dark: vars };
+}
+function replaceBlock(css, selector, newVars) {
+  const re = new RegExp(`(${selector.replace(".", "\\.")} \\{)[^}]*(\\})`, "s");
+  return css.replace(re, `$1
+${newVars}
+$2`);
+}
+async function applyTheme(options, cssPath, fsModule = nodeFsPromises2) {
+  let vars;
+  if (options.preset) {
+    const theme = PRESETS[options.preset];
+    if (!theme) {
+      throw new Error(`applyTheme: preset "${options.preset}" n\xE3o encontrado.`);
+    }
+    vars = theme;
+  } else if (options.accentColor) {
+    vars = buildCustomThemeVars(options.accentColor);
+  } else {
+    throw new Error("applyTheme: forne\xE7a preset ou accentColor.");
+  }
+  const css = await fsModule.readFile(cssPath, "utf-8");
+  let updated = replaceBlock(css, ":root", vars.root);
+  updated = replaceBlock(updated, ".dark", vars.dark);
+  await fsModule.writeFile(cssPath, updated);
+}
+
+// src/transforms/applyFont.ts
+import * as nodeFsPromises3 from "fs/promises";
+function fontToGoogleSlug(font) {
+  return font.replace(/ /g, "+");
+}
+function buildFontLink(font) {
+  const slug = fontToGoogleSlug(font);
+  return `<link
+      href="https://fonts.googleapis.com/css2?family=${slug}:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />`;
+}
+async function applyFont(options, paths, fsModule = nodeFsPromises3) {
+  const { fontSans, fontMono, radius } = options;
+  let css = await fsModule.readFile(paths.css, "utf-8");
+  css = css.replace(
+    /(--font-sans:\s*")[^"]*(")/,
+    `$1${fontSans}$2`
+  );
+  css = css.replace(
+    /(--font-mono:\s*")[^"]*(")/,
+    `$1${fontMono}$2`
+  );
+  css = css.replace(
+    /(--radius:\s*)[^;]+(;)/,
+    `$1${radius}$2`
+  );
+  await fsModule.writeFile(paths.css, css);
+  let html = await fsModule.readFile(paths.html, "utf-8");
+  const newLink = buildFontLink(fontSans);
+  html = html.replace(
+    /<link\s[^>]*fonts\.googleapis\.com\/css2[^>]*(?:\s*\/>|>[^<]*<\/link>)/s,
+    newLink
+  );
+  await fsModule.writeFile(paths.html, html);
+}
+
+// src/transforms/applyPlugins.ts
+import * as nodeFsPromises4 from "fs/promises";
+async function applyPlugins(plugins, registryPath, fsModule = nodeFsPromises4) {
+  let content = await fsModule.readFile(registryPath, "utf-8");
+  for (const [id, enabled] of Object.entries(plugins)) {
+    if (!content.includes(`id: '${id}'`)) {
+      throw new Error(`applyPlugins: plugin id "${id}" n\xE3o encontrado em "${registryPath}".`);
+    }
+    content = content.replace(
+      new RegExp(`(id: '${id}'[\\s\\S]*?defaultEnabled: )(?:true|false)`, ""),
+      `$1${enabled}`
+    );
+  }
+  await fsModule.writeFile(registryPath, content);
+}
+
+// src/transforms/applyIndexHtml.ts
+import * as nodeFsPromises5 from "fs/promises";
+function fontToGoogleSlug2(font) {
+  return font.replace(/ /g, "+");
+}
+async function applyIndexHtml(data, htmlPath, fsModule = nodeFsPromises5) {
+  let html = await fsModule.readFile(htmlPath, "utf-8");
+  const slug = fontToGoogleSlug2(data.fontFamily);
+  html = html.replace(
+    /<link\s[^>]*fonts\.googleapis\.com\/css2[^>]*(?:\s*\/>|>[^<]*<\/link>)/s,
+    `<link
+      href="https://fonts.googleapis.com/css2?family=${slug}:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />`
+  );
+  html = html.replace(
+    /(<meta\s+name="theme-color"\s+content=")[^"]*(")/,
+    `$1${data.themeColor}$2`
+  );
+  html = html.replace(
+    /(<meta\s+property="og:title"\s+content=")[^"]*(")/,
+    `$1${data.siteName}$2`
+  );
+  html = html.replace(
+    /(<meta\s+property="twitter:title"\s+content=")[^"]*(")/,
+    `$1${data.siteName}$2`
+  );
+  html = html.replace(
+    /(<meta\s+property="og:url"\s+content=")[^"]*(")/,
+    `$1${data.siteUrl}$2`
+  );
+  html = html.replace(
+    /(<meta\s+property="twitter:url"\s+content=")[^"]*(")/,
+    `$1${data.siteUrl}$2`
+  );
+  const handle = data.twitterHandle.startsWith("@") ? data.twitterHandle : `@${data.twitterHandle}`;
+  html = html.replace(
+    /(<meta\s+property="twitter:creator"\s+content=")[^"]*(")/,
+    `$1${handle}$2`
+  );
+  html = html.replace(
+    /(<meta\s+name="author"\s+content=")[^"]*(")/,
+    `$1${data.authorName}$2`
+  );
+  await fsModule.writeFile(htmlPath, html);
+}
+
+// src/transforms/applyRubricalConfig.ts
+import * as nodeFsPromises6 from "fs/promises";
+import * as path2 from "path";
+function generateContent(config) {
+  return `export const rubricalConfig = {
+  siteName: ${JSON.stringify(config.siteName)},
+  siteUrl: ${JSON.stringify(config.siteUrl)},
+  siteDescription: ${JSON.stringify(config.siteDescription)},
+  authorName: ${JSON.stringify(config.authorName)},
+  authorEmail: ${JSON.stringify(config.authorEmail)},
+  twitterHandle: ${JSON.stringify(config.twitterHandle)},
+  lang: ${JSON.stringify(config.lang)},
+  seoHomeTitle: ${JSON.stringify(config.seoHomeTitle)},
+  seoHomeDescription: ${JSON.stringify(config.seoHomeDescription)},
+  rssTitle: ${JSON.stringify(config.rssTitle)},
+  rssDescription: ${JSON.stringify(config.rssDescription)},
+  ogImageUrl: ${JSON.stringify(config.ogImageUrl)},
+  accentColor: ${JSON.stringify(config.accentColor)},
+  fontSans: ${JSON.stringify(config.fontSans)},
+  fontMono: ${JSON.stringify(config.fontMono)},
+  radius: ${JSON.stringify(config.radius)},
+};
+`;
+}
+async function applyRubricalConfig(config, targetDir, fsModule = nodeFsPromises6) {
+  const filePath = path2.join(targetDir, "rubrica.config.ts");
+  await fsModule.mkdir(targetDir, { recursive: true });
+  await fsModule.writeFile(filePath, generateContent(config));
+}
+
+// src/state/writeState.ts
+import * as nodeFsPromises8 from "fs/promises";
+import * as path4 from "path";
+
+// src/state/readState.ts
+import * as nodeFsPromises7 from "fs/promises";
+import * as path3 from "path";
+var DEFAULT_STATE = {
+  version: "0.0.0",
+  layout: "sidebar",
+  theme: "cyberpunk",
+  accentColor: null,
+  fontSans: "Inter",
+  fontMono: "JetBrains Mono",
+  radius: "0.5rem",
+  plugins: {}
+};
+async function readState(projectDir, fsModule = nodeFsPromises7) {
+  const filePath = path3.join(projectDir, "rubrica.json");
+  let raw;
+  try {
+    raw = await fsModule.readFile(filePath, "utf-8");
+  } catch {
+    const state = { ...DEFAULT_STATE };
+    await fsModule.mkdir(projectDir, { recursive: true });
+    await fsModule.writeFile(filePath, JSON.stringify(state, null, 2));
+    return state;
+  }
+  const parsed = JSON.parse(raw);
+  if (!("version" in parsed) || parsed.version === void 0) {
+    throw new Error(
+      `readState: campo obrigat\xF3rio "version" ausente em "${filePath}".`
+    );
+  }
+  if (!("layout" in parsed) || parsed.layout === void 0) {
+    throw new Error(
+      `readState: campo obrigat\xF3rio "layout" ausente em "${filePath}".`
+    );
+  }
+  return parsed;
+}
+
+// src/state/writeState.ts
+async function writeState(projectDir, partial, fsModule = nodeFsPromises8) {
+  const filePath = path4.join(projectDir, "rubrica.json");
+  let current;
+  try {
+    current = await readState(projectDir, fsModule);
+  } catch {
+    current = {};
+  }
+  const merged = { ...current, ...partial };
+  await fsModule.mkdir(projectDir, { recursive: true });
+  await fsModule.writeFile(filePath, JSON.stringify(merged, null, 2));
+  return merged;
+}
+
+// src/commands/create.ts
+var ALL_PLUGINS = [
+  "contact-wizard",
+  "proposals",
+  "payments",
+  "blog",
+  "portfolio",
+  "resume",
+  "about",
+  "ai-resumes",
+  "audit-log",
+  "media-manager",
+  "i18n",
+  "playground",
+  "testimonials",
+  "testimonials-intake"
+];
+function validateProjectName(name) {
+  if (/\s/.test(name)) {
+    throw new Error(
+      `Nome inv\xE1lido: "${name}" cont\xE9m espa\xE7os. Use h\xEDfens ou underscores (ex: meu-portfolio).`
+    );
+  }
+  if (/[^a-zA-Z0-9\-_]/.test(name)) {
+    throw new Error(
+      `Nome inv\xE1lido: "${name}" cont\xE9m caracteres especiais. Use apenas letras, n\xFAmeros, h\xEDfens e underscores.`
+    );
+  }
+}
+async function removeDir(dirPath, fs) {
+  if (await fs.exists(dirPath)) {
+    await fs.rm(dirPath, { recursive: true, force: true });
+  }
+}
+async function runCreate(projectName, deps) {
+  validateProjectName(projectName);
+  const fs = deps.fs ?? {
+    ...nodeFsPromises9,
+    exists: async (p) => {
+      try {
+        await nodeFsPromises9.access(p);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+  const download = deps.download ?? downloadRelease;
+  const getVersion = deps.getLatestVersion ?? getLatestVersion;
+  const applyLayoutFn = deps.applyLayout ?? applyLayout;
+  const applyThemeFn = deps.applyTheme ?? applyTheme;
+  const applyFontFn = deps.applyFont ?? applyFont;
+  const applyPluginsFn = deps.applyPlugins ?? applyPlugins;
+  const applyIndexHtmlFn = deps.applyIndexHtml ?? applyIndexHtml;
+  const applyRubricalConfigFn = deps.applyRubricalConfig ?? applyRubricalConfig;
+  const writeStateFn = deps.writeState ?? writeState;
+  const execFn = deps.exec ?? (async (cmd, cwd) => {
+    const { execSync } = await import("child_process");
+    execSync(cmd, { cwd, stdio: "inherit" });
+  });
+  const doIdentityPrompt = deps.identityPrompt ?? identityPrompt;
+  const projectDir = `${deps.projectsDir}/${projectName}`;
+  const version = await getVersion();
+  await download(projectDir, version);
+  const layout = await select2({
+    message: "Layout",
+    options: [
+      { value: "sidebar", label: "Sidebar \u2014 navega\xE7\xE3o lateral com perfil completo" },
+      { value: "topbar", label: "Topbar \u2014 navbar horizontal fixa no topo" },
+      { value: "centered", label: "Centered \u2014 sem nav persistente, foco no conte\xFAdo" }
+    ]
+  });
+  await applyLayoutFn(
+    layout,
+    { projectDir, templatesDir: `${projectDir}/templates` },
+    fs
+  );
+  const themeChoice = await select2({
+    message: "Tema visual",
+    options: [
+      { value: "cyberpunk", label: "Cyberpunk \u2014 neon purple + lime, atmosfera dark" },
+      { value: "minimal", label: "Minimal \u2014 clean, azul neutro, m\xE1xima legibilidade" },
+      { value: "editorial", label: "Editorial \u2014 creme, \xE2mbar, tipografia serifada" },
+      { value: "forest", label: "Forest \u2014 verde musgo, off-white, org\xE2nico" },
+      { value: "custom", label: "Personalizado..." }
+    ]
+  });
+  let accentColor;
+  if (themeChoice === "custom") {
+    const hexInput = await text2({
+      message: "Cor de destaque (hex, ex: #0065fe)",
+      validate: (v) => {
+        if (!/^#[0-9a-fA-F]{6}$/.test(v)) return "Informe um hex v\xE1lido (ex: #0065fe)";
+      }
+    });
+    accentColor = hexInput;
+  }
+  const themeOptions = themeChoice === "custom" ? { accentColor } : { preset: themeChoice };
+  await applyThemeFn(
+    themeOptions,
+    `${projectDir}/src/index.css`,
+    fs
+  );
+  const fontSans = await select2({
+    message: "Fonte principal",
+    options: [
+      { value: "Inter", label: "Inter \u2014 neutra, leg\xEDvel, padr\xE3o de produtos digitais" },
+      { value: "Chakra Petch", label: "Chakra Petch \u2014 geom\xE9trica, tech, futurista" },
+      { value: "Playfair Display", label: "Playfair Display \u2014 elegante, editorial" },
+      { value: "Space Grotesk", label: "Space Grotesk \u2014 moderna, startup" },
+      { value: "DM Sans", label: "DM Sans \u2014 limpa, amig\xE1vel, vers\xE1til" }
+    ]
+  });
+  const fontMono = await select2({
+    message: "Fonte mono",
+    options: [
+      { value: "JetBrains Mono", label: "JetBrains Mono \u2014 dev-friendly, clara" },
+      { value: "Fira Code", label: "Fira Code \u2014 cl\xE1ssico, com ligatures" },
+      { value: "Space Mono", label: "Space Mono \u2014 retro digital" },
+      { value: "IBM Plex Mono", label: "IBM Plex Mono \u2014 corporativo-tech" }
+    ]
+  });
+  const radius = await select2({
+    message: "Border radius",
+    options: [
+      { value: "0rem", label: "Nenhum \u2014 bordas retas, minimalismo severo" },
+      { value: "0.375rem", label: "Suave \u2014 sutil arredondamento" },
+      { value: "0.5rem", label: "M\xE9dio \u2014 padr\xE3o shadcn/ui" },
+      { value: "0.75rem", label: "Arredondado \u2014 amig\xE1vel, moderno" },
+      { value: "1rem", label: "Pill \u2014 muito arredondado, jovial" }
+    ]
+  });
+  await applyFontFn(
+    { fontSans, fontMono, radius },
+    { css: `${projectDir}/src/index.css`, html: `${projectDir}/index.html` },
+    fs
+  );
+  const selectedPlugins = await multiselect({
+    message: "Plugins ativos",
+    options: [
+      { value: "contact-wizard", label: "Contact Wizard \u2014 formul\xE1rio de contato multi-etapas", hint: "recomendado" },
+      { value: "proposals", label: "Propostas \u2014 propostas comerciais com assinatura eletr\xF4nica", hint: "recomendado" },
+      { value: "payments", label: "Pagamentos \u2014 integra\xE7\xE3o com Stripe/Asaas" },
+      { value: "blog", label: "Blog \u2014 listagem e leitura de posts", hint: "recomendado" },
+      { value: "portfolio", label: "Portfolio \u2014 galeria de projetos", hint: "recomendado" },
+      { value: "resume", label: "Curr\xEDculo \u2014 curr\xEDculo interativo com download de PDF", hint: "recomendado" },
+      { value: "about", label: "Sobre \u2014 p\xE1gina sobre mim", hint: "recomendado" },
+      { value: "ai-resumes", label: "CV com IA \u2014 gera\xE7\xE3o de curr\xEDculo customizado por IA" },
+      { value: "audit-log", label: "Audit Log \u2014 log de auditoria do painel admin", hint: "recomendado" },
+      { value: "media-manager", label: "Media Manager \u2014 gerenciador de arquivos e imagens" },
+      { value: "i18n", label: "Tradu\xE7\xE3o IA \u2014 internacionaliza\xE7\xE3o autom\xE1tica de conte\xFAdo" },
+      { value: "playground", label: "Playground \u2014 ambiente de testes interativo" },
+      { value: "testimonials", label: "Depoimentos \u2014 se\xE7\xE3o de testimoniais de clientes", hint: "recomendado" },
+      { value: "testimonials-intake", label: "Coleta de Depoimentos \u2014 formul\xE1rio p\xFAblico para coleta", hint: "recomendado" }
+    ],
+    required: false
+  });
+  const pluginsRecord = Object.fromEntries(
+    ALL_PLUGINS.map((id) => [id, selectedPlugins.includes(id)])
+  );
+  await applyPluginsFn(
+    pluginsRecord,
+    `${projectDir}/convex/pluginRegistry.ts`,
+    fs
+  );
+  const identity = await doIdentityPrompt();
+  await applyIndexHtmlFn(
+    {
+      fontFamily: fontSans,
+      themeColor: accentColor ?? "#6d28d9",
+      siteName: identity.siteName,
+      siteUrl: identity.siteUrl,
+      twitterHandle: identity.twitterHandle,
+      authorName: identity.authorName
+    },
+    `${projectDir}/index.html`,
+    fs
+  );
+  await applyRubricalConfigFn(
+    {
+      siteName: identity.siteName,
+      siteUrl: identity.siteUrl,
+      siteDescription: identity.siteDescription,
+      authorName: identity.authorName,
+      authorEmail: identity.authorEmail,
+      twitterHandle: identity.twitterHandle,
+      lang: identity.lang,
+      seoHomeTitle: identity.siteName,
+      seoHomeDescription: identity.siteDescription,
+      rssTitle: identity.siteName,
+      rssDescription: identity.siteDescription,
+      ogImageUrl: `${identity.siteUrl}/og.png`,
+      accentColor: accentColor ?? "#6d28d9",
+      fontSans,
+      fontMono
+    },
+    projectDir,
+    fs
+  );
+  const pkgPath = `${projectDir}/package.json`;
+  const pkgRaw = await fs.readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(pkgRaw);
+  pkg.name = projectName;
+  await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+  await writeStateFn(
+    projectDir,
+    {
+      version: "0.1.0",
+      layout,
+      theme: themeChoice === "custom" ? "custom" : themeChoice,
+      accentColor: accentColor ?? null,
+      fontSans,
+      fontMono,
+      radius,
+      plugins: pluginsRecord
+    },
+    fs
+  );
+  const doGitInit = await confirm({ message: "Inicializar reposit\xF3rio git?" });
+  const packageManager = await select2({
+    message: "Gerenciador de pacotes",
+    options: [
+      { value: "pnpm", label: "pnpm (recomendado)" },
+      { value: "npm", label: "npm" },
+      { value: "none", label: "N\xE3o agora" }
+    ]
+  });
+  if (doGitInit) {
+    await execFn("git init", projectDir);
+  }
+  if (packageManager !== "none") {
+    await execFn(`${packageManager} install`, projectDir);
+  }
+  await removeDir(`${projectDir}/templates`, fs);
+  await removeDir(`${projectDir}/cli`, fs);
+  const installStep = packageManager === "none" ? "pnpm install\n  " : "";
+  outro(
+    `Projeto criado com sucesso!
+
+  cd ${projectName}
+
+Pr\xF3ximos passos:
+
+  1. Suba o backend:
+     npx convex dev
+     (deixe rodando em um terminal)
+
+  2. Configure o ambiente (em outro terminal, com Convex ativo):
+     rubrica setup
+
+  3. Inicie o frontend:
+     ${installStep}pnpm dev
+
+Boa sorte! \u{1F680}`
+  );
+}
+
+// src/commands/config.ts
+import { outro as outro2, select as select3, multiselect as multiselect2, confirm as confirm2, isCancel as isCancel3, cancel as cancel3 } from "@clack/prompts";
+import * as nodeFsPromises11 from "fs/promises";
+import * as path6 from "path";
+
+// src/utils/detectProject.ts
+import * as nodeFsPromises10 from "fs/promises";
+import * as path5 from "path";
+async function detectProject(startDir, fsModule = nodeFsPromises10) {
+  let current = startDir;
+  while (true) {
+    const candidate = path5.join(current, "rubrica.json");
+    try {
+      await fsModule.access(candidate);
+      return candidate;
+    } catch {
+      const parent = path5.dirname(current);
+      if (parent === current) {
+        throw new Error(
+          `detectProject: nenhum rubrica.json encontrado em "${startDir}" nem em nenhum diret\xF3rio ancestral.`
+        );
+      }
+      current = parent;
+    }
+  }
+}
+
+// src/commands/config.ts
+var ALL_PLUGINS2 = [
+  "blog",
+  "portfolio",
+  "resume",
+  "about",
+  "proposals",
+  "payments",
+  "ai-resumes",
+  "i18n",
+  "playground",
+  "testimonials",
+  "testimonials-intake",
+  "contact-wizard",
+  "audit-log"
+];
+async function runConfig(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const fs = deps.fs ?? nodeFsPromises11;
+  const detectProjectFn = deps.detectProject ?? detectProject;
+  const readStateFn = deps.readState ?? readState;
+  const writeStateFn = deps.writeState ?? writeState;
+  const doIdentityPrompt = deps.identityPrompt ?? identityPrompt;
+  const applyRubricalConfigFn = deps.applyRubricalConfig ?? applyRubricalConfig;
+  const applyThemeFn = deps.applyTheme ?? applyTheme;
+  const applyFontFn = deps.applyFont ?? applyFont;
+  const applyIndexHtmlFn = deps.applyIndexHtml ?? applyIndexHtml;
+  const applyLayoutFn = deps.applyLayout ?? applyLayout;
+  const applyPluginsFn = deps.applyPlugins ?? applyPlugins;
+  const rubricaJsonPath = await detectProjectFn(cwd, fs);
+  const projectDir = path6.dirname(rubricaJsonPath);
+  const currentState = await readStateFn(projectDir, fs);
+  const stateUpdate = {};
+  const sections = await multiselect2({
+    message: "O que deseja reconfigurar?",
+    options: [
+      { value: "identity", label: "Identidade (nome, URL, SEO, RSS)" },
+      { value: "appearance", label: "Apar\xEAncia (tema, cores, fonte, radius)" },
+      { value: "layout", label: "Layout (sidebar / topbar / centered)" },
+      { value: "plugins", label: "Plugins" }
+    ],
+    required: false
+  });
+  if (isCancel3(sections)) {
+    cancel3("Opera\xE7\xE3o cancelada.");
+    return;
+  }
+  const selected = sections;
+  if (selected.includes("identity")) {
+    const identityData = await doIdentityPrompt();
+    await applyRubricalConfigFn(
+      {
+        siteName: identityData.siteName,
+        siteUrl: identityData.siteUrl,
+        siteDescription: identityData.siteDescription,
+        authorName: identityData.authorName,
+        authorEmail: identityData.authorEmail,
+        twitterHandle: identityData.twitterHandle,
+        lang: identityData.lang,
+        seoHomeTitle: "",
+        seoHomeDescription: "",
+        rssTitle: "",
+        rssDescription: "",
+        ogImageUrl: "",
+        accentColor: currentState.accentColor ?? "",
+        fontSans: currentState.fontSans,
+        fontMono: currentState.fontMono,
+        radius: currentState.radius
+      },
+      projectDir,
+      fs
+    );
+  }
+  if (selected.includes("appearance")) {
+    const theme = await select3({
+      message: "Tema visual",
+      initialValue: currentState.theme,
+      options: [
+        { value: "cyberpunk", label: "Cyberpunk \u2014 neon purple + lime" },
+        { value: "minimal", label: "Minimal \u2014 clean, azul neutro" },
+        { value: "editorial", label: "Editorial \u2014 creme, \xE2mbar, serifado" },
+        { value: "forest", label: "Forest \u2014 verde musgo, off-white" }
+      ]
+    });
+    const fontSans = await select3({
+      message: "Fonte principal",
+      initialValue: currentState.fontSans,
+      options: [
+        { value: "Inter", label: "Inter \u2014 neutra, padr\xE3o de produtos digitais" },
+        { value: "Chakra Petch", label: "Chakra Petch \u2014 geom\xE9trica, tech" },
+        { value: "Playfair Display", label: "Playfair Display \u2014 elegante, editorial" },
+        { value: "Space Grotesk", label: "Space Grotesk \u2014 moderna, startup" },
+        { value: "DM Sans", label: "DM Sans \u2014 limpa, amig\xE1vel" }
+      ]
+    });
+    const fontMono = await select3({
+      message: "Fonte mono",
+      initialValue: currentState.fontMono,
+      options: [
+        { value: "JetBrains Mono", label: "JetBrains Mono" },
+        { value: "Fira Code", label: "Fira Code" },
+        { value: "Space Mono", label: "Space Mono" },
+        { value: "IBM Plex Mono", label: "IBM Plex Mono" }
+      ]
+    });
+    const radius = await select3({
+      message: "Border radius",
+      initialValue: currentState.radius,
+      options: [
+        { value: "0rem", label: "Nenhum \u2014 0rem" },
+        { value: "0.375rem", label: "Suave \u2014 0.375rem" },
+        { value: "0.5rem", label: "M\xE9dio \u2014 0.5rem" },
+        { value: "0.75rem", label: "Arredondado \u2014 0.75rem" },
+        { value: "1rem", label: "Pill \u2014 1rem" }
+      ]
+    });
+    const cssPath = path6.join(projectDir, "src", "index.css");
+    const htmlPath = path6.join(projectDir, "index.html");
+    await applyThemeFn(
+      { preset: theme },
+      cssPath,
+      fs
+    );
+    await applyFontFn(
+      { fontSans, fontMono, radius },
+      { css: cssPath, html: htmlPath },
+      fs
+    );
+    await applyIndexHtmlFn(
+      { fontFamily: fontSans, themeColor: "", siteName: "", siteUrl: "", twitterHandle: "", authorName: "" },
+      htmlPath,
+      fs
+    );
+    stateUpdate.theme = theme;
+    stateUpdate.fontSans = fontSans;
+    stateUpdate.fontMono = fontMono;
+    stateUpdate.radius = radius;
+    stateUpdate.accentColor = null;
+  }
+  if (selected.includes("layout")) {
+    const newLayout = await select3({
+      message: "Layout",
+      initialValue: currentState.layout,
+      options: [
+        { value: "sidebar", label: "Sidebar \u2014 navega\xE7\xE3o lateral com perfil completo" },
+        { value: "topbar", label: "Topbar \u2014 navbar horizontal fixa no topo" },
+        { value: "centered", label: "Centered \u2014 sem nav persistente, foco no conte\xFAdo" }
+      ]
+    });
+    const confirmed = await confirm2({
+      message: "\u26A0 Isso sobrescreve Layout.tsx e arquivos de navega\xE7\xE3o. Customiza\xE7\xF5es manuais ser\xE3o perdidas. Continuar?"
+    });
+    if (!isCancel3(confirmed) && confirmed === true) {
+      await applyLayoutFn(
+        newLayout,
+        { projectDir, templatesDir: path6.join(projectDir, "templates") },
+        fs
+      );
+      stateUpdate.layout = newLayout;
+    }
+  }
+  if (selected.includes("plugins")) {
+    const activePlugins = Object.entries(currentState.plugins).filter(([, v]) => v).map(([k]) => k);
+    const selectedPlugins = await multiselect2({
+      message: "Plugins ativos",
+      initialValues: activePlugins,
+      options: ALL_PLUGINS2.map((p) => ({ value: p, label: p })),
+      required: false
+    });
+    if (!isCancel3(selectedPlugins)) {
+      const pluginsMap = {};
+      for (const p of ALL_PLUGINS2) {
+        pluginsMap[p] = selectedPlugins.includes(p);
+      }
+      await applyPluginsFn(
+        pluginsMap,
+        path6.join(projectDir, "convex", "pluginRegistry.ts"),
+        fs
+      );
+      stateUpdate.plugins = pluginsMap;
+    }
+  }
+  if (Object.keys(stateUpdate).length > 0) {
+    await writeStateFn(projectDir, stateUpdate, fs);
+  }
+  outro2("Configura\xE7\xE3o atualizada com sucesso!");
+}
+
+// src/commands/update.ts
+import { intro as intro2, outro as outro3, confirm as confirm3, isCancel as isCancel4, cancel as cancel4, log as log2 } from "@clack/prompts";
+import * as nodeFsPromises12 from "fs/promises";
+import * as path7 from "path";
+
+// src/utils/checkRequiredEnv.ts
+function parseEnvKeys(content) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex > 0) {
+      keys.add(trimmed.slice(0, eqIndex).trim());
+    }
+  }
+  return keys;
+}
+async function readEnvKeys(filePath, fs) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return parseEnvKeys(content);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function checkRequiredEnv(projectDir, fs) {
+  let required = [];
+  try {
+    const raw = await fs.readFile(`${projectDir}/required-env.json`, "utf-8");
+    required = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!required.length) return [];
+  const envKeys = await readEnvKeys(`${projectDir}/.env`, fs);
+  const envLocalKeys = await readEnvKeys(`${projectDir}/.env.local`, fs);
+  const allKeys = /* @__PURE__ */ new Set([...envKeys, ...envLocalKeys]);
+  return required.filter((v) => !allKeys.has(v.name));
+}
+
+// src/commands/update.ts
+function parseMajor(version) {
+  const clean = version.replace(/^v/, "");
+  const major = parseInt(clean.split(".")[0] ?? "0", 10);
+  return isNaN(major) ? 0 : major;
+}
+function normalizeVersion(version) {
+  return version.replace(/^v/, "");
+}
+async function runUpdate(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const fs = deps.fs ?? {
+    ...nodeFsPromises12,
+    exists: async (p) => {
+      try {
+        await nodeFsPromises12.access(p);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+  const detectProjectFn = deps.detectProject ?? detectProject;
+  const readStateFn = deps.readState ?? readState;
+  const writeStateFn = deps.writeState ?? writeState;
+  const getLatestVersionFn = deps.getLatestVersion ?? getLatestVersion;
+  const downloadReleaseFn = deps.downloadRelease ?? downloadRelease;
+  const applyLayoutFn = deps.applyLayout ?? applyLayout;
+  const applyThemeFn = deps.applyTheme ?? applyTheme;
+  const applyFontFn = deps.applyFont ?? applyFont;
+  const applyPluginsFn = deps.applyPlugins ?? applyPlugins;
+  const applyIndexHtmlFn = deps.applyIndexHtml ?? applyIndexHtml;
+  const applyRubricalConfigFn = deps.applyRubricalConfig ?? applyRubricalConfig;
+  const checkRequiredEnvFn = deps.checkRequiredEnv ?? checkRequiredEnv;
+  const execFn = deps.exec ?? (async (cmd, cwd2) => {
+    const { execSync } = await import("child_process");
+    execSync(cmd, { cwd: cwd2, stdio: "inherit" });
+  });
+  intro2("Rubrica Update");
+  const rubricaJsonPath = await detectProjectFn(cwd, fs);
+  const projectDir = path7.dirname(rubricaJsonPath);
+  const state = await readStateFn(projectDir, fs);
+  const localVersion = normalizeVersion(state.version);
+  const remoteVersion = normalizeVersion(await getLatestVersionFn());
+  if (localVersion === remoteVersion) {
+    outro3(`J\xE1 est\xE1 na vers\xE3o mais recente (${localVersion}). Nenhuma atualiza\xE7\xE3o necess\xE1ria.`);
+    return;
+  }
+  const localMajor = parseMajor(localVersion);
+  const remoteMajor = parseMajor(remoteVersion);
+  if (remoteMajor > localMajor) {
+    log2.warn(
+      `Atualiza\xE7\xE3o major detectada: ${localVersion} \u2192 ${remoteVersion}
+Atualiza\xE7\xF5es major podem conter mudan\xE7as destrutivas no schema do Convex.
+Consulte o guia de migra\xE7\xE3o antes de prosseguir.`
+    );
+    const majorConfirmed = await confirm3({
+      message: `Confirmar atualiza\xE7\xE3o major (${localVersion} \u2192 ${remoteVersion})? Pode haver mudan\xE7as destrutivas.`
+    });
+    if (isCancel4(majorConfirmed) || !majorConfirmed) {
+      cancel4("Atualiza\xE7\xE3o cancelada.");
+      return;
+    }
+  }
+  if (remoteMajor === localMajor) {
+    const proceed = await confirm3({
+      message: `Atualizar de ${localVersion} para ${remoteVersion}?`
+    });
+    if (isCancel4(proceed) || !proceed) {
+      cancel4("Atualiza\xE7\xE3o cancelada.");
+      return;
+    }
+  }
+  await downloadReleaseFn(projectDir, remoteVersion);
+  const templatesDir = path7.join(projectDir, "templates");
+  await applyLayoutFn(
+    state.layout,
+    { projectDir, templatesDir },
+    fs
+  );
+  const cssPath = path7.join(projectDir, "src", "index.css");
+  const themeOpts = state.theme && state.theme !== "custom" ? { preset: state.theme } : { accentColor: state.accentColor ?? "#6366f1" };
+  await applyThemeFn(themeOpts, cssPath, fs);
+  const htmlPath = path7.join(projectDir, "index.html");
+  await applyFontFn(
+    { fontSans: state.fontSans, fontMono: state.fontMono, radius: state.radius },
+    { css: cssPath, html: htmlPath },
+    fs
+  );
+  const registryPath = path7.join(projectDir, "convex", "pluginRegistry.ts");
+  await applyPluginsFn(
+    state.plugins,
+    registryPath,
+    fs
+  );
+  const identity = {
+    siteName: "",
+    siteUrl: "",
+    siteDescription: "",
+    authorName: "",
+    authorEmail: "",
+    twitterHandle: "",
+    lang: "pt-BR",
+    seoHomeTitle: "",
+    seoHomeDescription: "",
+    rssTitle: "",
+    rssDescription: "",
+    ogImageUrl: "",
+    accentColor: state.accentColor ?? "#6366f1",
+    fontSans: state.fontSans,
+    fontMono: state.fontMono,
+    radius: state.radius
+  };
+  await applyIndexHtmlFn(
+    {
+      fontFamily: identity.fontSans,
+      themeColor: identity.accentColor,
+      siteName: identity.siteName,
+      siteUrl: identity.siteUrl,
+      twitterHandle: identity.twitterHandle,
+      authorName: identity.authorName
+    },
+    htmlPath,
+    fs
+  );
+  await applyRubricalConfigFn(
+    identity,
+    projectDir,
+    fs
+  );
+  await writeStateFn(projectDir, { version: remoteVersion }, fs);
+  const missingVars = await checkRequiredEnvFn(projectDir, fs);
+  if (missingVars.length > 0) {
+    const varList = missingVars.map((v) => `  \u2022 ${v.name} \u2014 ${v.description}`).join("\n");
+    log2.warn(
+      `Vari\xE1veis de ambiente faltantes no Convex Dashboard:
+${varList}
+Configure-as em: https://dashboard.convex.dev`
+    );
+  }
+  outro3(`Rubrica atualizado para ${remoteVersion} com sucesso!`);
+}
+
+// src/commands/setup.ts
+import { outro as outro4, text as text3, password, spinner, isCancel as isCancel5, cancel as cancel5 } from "@clack/prompts";
+import * as nodeFsPromises13 from "fs/promises";
+import * as path8 from "path";
+import * as nodeCrypto from "crypto";
+import { execFileSync as defaultExecFileSync } from "child_process";
+
+// src/utils/generateJwtKeys.ts
+import { generateKeyPair, exportPKCS8, exportJWK } from "jose";
+async function generateJwtKeys() {
+  const { privateKey, publicKey } = await generateKeyPair("RS256", { extractable: true });
+  const JWT_PRIVATE_KEY = await exportPKCS8(privateKey);
+  const jwk = await exportJWK(publicKey);
+  const JWKS = JSON.stringify({ keys: [{ use: "sig", ...jwk }] });
+  return { JWT_PRIVATE_KEY, JWKS };
+}
+
+// src/commands/setup.ts
+function parseEnvFile(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+async function runSetup(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const fs = deps.fs ?? {
+    access: (p) => nodeFsPromises13.access(p).then(() => void 0),
+    readFile: (p, enc) => nodeFsPromises13.readFile(p, enc),
+    writeFile: (p, data) => nodeFsPromises13.writeFile(p, data).then(() => void 0),
+    mkdir: (p, opts) => nodeFsPromises13.mkdir(p, opts).then(() => void 0)
+  };
+  const detectProject2 = deps.detectProject ?? detectProject;
+  const generateJwtKeys2 = deps.generateJwtKeys ?? generateJwtKeys;
+  const readState2 = deps.readState ?? readState;
+  const randomBytes2 = deps.randomBytes ?? ((size) => nodeCrypto.randomBytes(size));
+  const execFileSync = deps.execFileSync ?? ((file, args, opts) => defaultExecFileSync(file, args, opts));
+  try {
+    await detectProject2(cwd);
+  } catch (err) {
+    cancel5(err.message);
+    return;
+  }
+  const envPath = path8.join(cwd, ".env.local");
+  let envVars = {};
+  try {
+    const envContent = await fs.readFile(envPath, "utf-8");
+    envVars = parseEnvFile(envContent);
+  } catch {
+    cancel5(
+      "Arquivo .env.local n\xE3o encontrado. Rode npx convex dev primeiro para cri\xE1-lo."
+    );
+    return;
+  }
+  if (!envVars["VITE_CONVEX_URL"]) {
+    cancel5(
+      "VITE_CONVEX_URL n\xE3o encontrado no .env.local. Rode npx convex dev primeiro."
+    );
+    return;
+  }
+  if (!envVars["VITE_CONVEX_SITE_URL"]) {
+    cancel5(
+      "VITE_CONVEX_SITE_URL n\xE3o encontrado no .env.local. Rode npx convex dev primeiro."
+    );
+    return;
+  }
+  const siteUrlDefault = envVars["VITE_CONVEX_SITE_URL"];
+  const s = spinner();
+  s.start("Gerando chaves JWT (RS256)...");
+  const { JWT_PRIVATE_KEY, JWKS } = await generateJwtKeys2();
+  s.stop("Chaves JWT geradas.");
+  execFileSync("npx", ["convex", "env", "set", "--", "JWT_PRIVATE_KEY", JWT_PRIVATE_KEY], {
+    stdio: "pipe"
+  });
+  execFileSync("npx", ["convex", "env", "set", "--", "JWKS", JWKS], {
+    stdio: "pipe"
+  });
+  const siteUrl = await text3({
+    message: "URL p\xFAblica do site (SITE_URL no Convex):",
+    initialValue: siteUrlDefault,
+    validate: (v) => {
+      if (!v || !v.startsWith("http://") && !v.startsWith("https://"))
+        return "URL deve come\xE7ar com http:// ou https://";
+    }
+  });
+  if (isCancel5(siteUrl)) {
+    cancel5("Setup cancelado.");
+    return;
+  }
+  execFileSync("npx", ["convex", "env", "set", "--", "SITE_URL", siteUrl], {
+    stdio: "pipe"
+  });
+  const state = await readState2(cwd, fs);
+  const plugins = state.plugins;
+  if (plugins["contact-wizard"] || plugins["testimonials-intake"]) {
+    const telegramToken = await text3({
+      message: "TELEGRAM_BOT_TOKEN (Enter para pular):",
+      initialValue: ""
+    });
+    if (!isCancel5(telegramToken) && telegramToken.trim()) {
+      execFileSync("npx", ["convex", "env", "set", "--", "TELEGRAM_BOT_TOKEN", telegramToken], { stdio: "pipe" });
+    }
+    const telegramChatId = await text3({
+      message: "TELEGRAM_ADMIN_CHAT_ID (Enter para pular):",
+      initialValue: ""
+    });
+    if (!isCancel5(telegramChatId) && telegramChatId.trim()) {
+      execFileSync("npx", ["convex", "env", "set", "--", "TELEGRAM_ADMIN_CHAT_ID", telegramChatId], { stdio: "pipe" });
+    }
+  }
+  if (plugins["playground"]) {
+    const pepper = randomBytes2(32).toString("hex");
+    execFileSync("npx", ["convex", "env", "set", "--", "PLAYGROUND_KEY_PEPPER", pepper], { stdio: "pipe" });
+  }
+  if (plugins["ai-resumes"] || plugins["i18n"] || plugins["playground"]) {
+    const openrouterKey = await text3({
+      message: "OPENROUTER_API_KEY (Enter para pular):",
+      initialValue: ""
+    });
+    if (!isCancel5(openrouterKey) && openrouterKey.trim()) {
+      execFileSync("npx", ["convex", "env", "set", "--", "OPENROUTER_API_KEY", openrouterKey], { stdio: "pipe" });
+    }
+  }
+  if (plugins["payments"]) {
+    const stripeSecret = await text3({
+      message: "STRIPE_WEBHOOK_SECRET (Enter para pular):",
+      initialValue: ""
+    });
+    if (!isCancel5(stripeSecret) && stripeSecret.trim()) {
+      execFileSync("npx", ["convex", "env", "set", "--", "STRIPE_WEBHOOK_SECRET", stripeSecret], { stdio: "pipe" });
+    }
+    const asaasToken = await text3({
+      message: "ASAAS_WEBHOOK_TOKEN (Enter para pular):",
+      initialValue: ""
+    });
+    if (!isCancel5(asaasToken) && asaasToken.trim()) {
+      execFileSync("npx", ["convex", "env", "set", "--", "ASAAS_WEBHOOK_TOKEN", asaasToken], { stdio: "pipe" });
+    }
+  }
+  const adminEmail = await text3({
+    message: "Email do usu\xE1rio root:",
+    validate: (v) => {
+      if (!v.includes("@") || !v.includes("."))
+        return "Email inv\xE1lido \u2014 deve conter @ e pelo menos um ponto";
+    }
+  });
+  if (isCancel5(adminEmail)) {
+    cancel5("Setup cancelado.");
+    return;
+  }
+  const adminPassword = await password({
+    message: "Senha do usu\xE1rio root (m\xEDnimo 12 caracteres):",
+    validate: (v) => {
+      if (v.length < 12) return "Senha deve ter pelo menos 12 caracteres";
+    }
+  });
+  if (isCancel5(adminPassword)) {
+    cancel5("Setup cancelado.");
+    return;
+  }
+  const adminPasswordConfirm = await password({
+    message: "Confirme a senha:",
+    validate: (v) => {
+      if (v !== adminPassword) return "As senhas n\xE3o coincidem";
+    }
+  });
+  if (isCancel5(adminPasswordConfirm)) {
+    cancel5("Setup cancelado.");
+    return;
+  }
+  try {
+    execFileSync(
+      "npx",
+      ["convex", "run", "seed:setupAdmin", JSON.stringify({ email: adminEmail, password: adminPassword })],
+      { stdio: "pipe" }
+    );
+  } catch (err) {
+    const e = err;
+    const output = e.stdout?.toString() ?? e.stderr?.toString() ?? e.message ?? "";
+    if (output.includes("Root user already exists")) {
+      cancel5("Admin j\xE1 configurado. Para redefinir, acesse o Convex Dashboard.");
+    } else {
+      cancel5(`Erro ao criar usu\xE1rio root: ${output || String(err)}`);
+    }
+    return;
+  }
+  const vercelHookUrl = await text3({
+    message: "VERCEL_DEPLOY_HOOK_URL (Enter para pular):",
+    initialValue: ""
+  });
+  if (!isCancel5(vercelHookUrl) && vercelHookUrl.trim()) {
+    execFileSync("npx", ["convex", "env", "set", "--", "VERCEL_DEPLOY_HOOK_URL", vercelHookUrl], { stdio: "pipe" });
+  }
+  const vercelWebhookSecret = await text3({
+    message: "VERCEL_WEBHOOK_SECRET (Enter para pular):",
+    initialValue: ""
+  });
+  if (!isCancel5(vercelWebhookSecret) && vercelWebhookSecret.trim()) {
+    execFileSync("npx", ["convex", "env", "set", "--", "VERCEL_WEBHOOK_SECRET", vercelWebhookSecret], { stdio: "pipe" });
+  }
+  outro4(
+    `Setup conclu\xEDdo!
+
+  Admin criado: ${adminEmail}
+  Acesse: /login
+
+  Pr\xF3ximo passo: pnpm dev`
+  );
+}
+
+// src/index.ts
+async function runCli(argv, cwd) {
+  const [, , command, projectName] = argv;
+  intro3("Rubrica CLI");
+  if (command === "create") {
+    if (!projectName) {
+      console.error("Uso: rubrica create <nome-do-projeto>");
+      process.exit(1);
+    }
+    await runCreate(projectName, { projectsDir: cwd });
+  } else if (command === "config") {
+    await runConfig({ cwd });
+  } else if (command === "update") {
+    await runUpdate({ cwd });
+  } else if (command === "setup") {
+    await runSetup({ cwd });
+  } else {
+    console.log("Comandos dispon\xEDveis: create <nome-do-projeto> | config | update | setup");
+  }
+}
+await runCli(process.argv, process.cwd());
+export {
+  runCli
+};