svelte-vitals 0.17.0 → 0.19.0

package/dist/bin.js

@@ -6,12 +6,55 @@ import {
   knownRuleIds,
   readPackageVersion,
   run
-} from "./chunk-VG647TPJ.js";
+} from "./chunk-ZE3M3T6U.js";
 
 // src/bin.ts
 import mri2 from "mri";
 
 // src/resolve-args.ts
+var CATEGORIES = ["seo", "performance", "correctness", "security", "architecture"];
+function parseWeights(raw, errors) {
+  if (typeof raw !== "string" || raw.trim() === "") return void 0;
+  const weights = {};
+  const unknownCategories = [];
+  const invalidValues = [];
+  for (const pair of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      invalidValues.push(pair);
+      continue;
+    }
+    const category = pair.slice(0, eq).trim().toLowerCase();
+    const valueRaw = pair.slice(eq + 1).trim();
+    if (!CATEGORIES.includes(category)) {
+      unknownCategories.push(category);
+      continue;
+    }
+    if (valueRaw === "") {
+      invalidValues.push(pair);
+      continue;
+    }
+    const value = Number(valueRaw);
+    if (!Number.isFinite(value) || value < 0) {
+      invalidValues.push(pair);
+      continue;
+    }
+    weights[category] = value;
+  }
+  if (unknownCategories.length > 0) {
+    errors.push(`svelte-vitals: unknown category(ies) in --weights: ${unknownCategories.join(", ")}`);
+    errors.push(`Known categories: ${CATEGORIES.join(", ")}`);
+  }
+  if (invalidValues.length > 0) {
+    errors.push(
+      `svelte-vitals: invalid --weights entry(ies): ${invalidValues.join(", ")}; expected category=number with a finite number >= 0.`
+    );
+  }
+  if (unknownCategories.length === 0 && invalidValues.length === 0 && Object.keys(weights).length === 0) {
+    errors.push("svelte-vitals: --weights was passed but contains no category=number pairs.");
+  }
+  return weights;
+}
 var toList = (v) => typeof v === "string" ? v.split(",").map((s) => s.trim()).filter(Boolean) : [];
 function resolveArgs(argv) {
   const warnings = [];
@@ -55,6 +98,9 @@ function resolveArgs(argv) {
     );
   }
   const failOn = argv["fail-on-warning"] ? "warning" : failOnValid ? failOnRaw : void 0;
+  const weights = parseWeights(argv.weights, errors);
+  const rulesConfig = buildRulesConfig(allow, ignore);
+  const rules = Object.keys(rulesConfig).length > 0 ? rulesConfig : void 0;
   if (errors.length > 0) return { options: null, warnings, errors };
   return {
     options: {
@@ -66,7 +112,8 @@ function resolveArgs(argv) {
       outFile: typeof argv["out-file"] === "string" ? argv["out-file"] : void 0,
       byRoute: Boolean(argv["by-route"]),
       failOn,
-      rules: buildRulesConfig(allow, ignore),
+      rules,
+      ...weights !== void 0 ? { weights } : {},
       ...diffBase !== void 0 ? { diffBase } : {},
       ...staged ? { staged } : {}
     },
@@ -79,9 +126,13 @@ function resolveArgs(argv) {
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { homedir } from "os";
+import { spawnSync } from "child_process";
 import mri from "mri";
 import * as p from "@clack/prompts";
 
+// src/install/index.ts
+import { join as join3 } from "path";
+
 // src/install/clients.ts
 import { join } from "path";
 var MCP_ENTRY = { command: "npx", args: ["-y", "@svelte-vitals/mcp"] };
@@ -165,12 +216,192 @@ function mergeToml(existing, entry, force) {
   return { content: stringifyToml(root), status };
 }
 
+// src/install/vite-targets.ts
+var VITE_TARGETS = [
+  {
+    id: "vite-plugin",
+    label: "Vite plugin (build gate)",
+    hint: "Fails `vite build` when prerendered pages cross the SEO/Performance threshold"
+  },
+  {
+    id: "vite-dev-overlay",
+    label: "Dev overlay",
+    hint: "Live warnings in `vite dev` only \u2014 never fails a build or CI"
+  }
+];
+function viteTargetById(id) {
+  return VITE_TARGETS.find((t) => t.id === id);
+}
+function isViteTargetId(id) {
+  return VITE_TARGETS.some((t) => t.id === id);
+}
+
+// src/install/codemod-vite-config.ts
+import { parseModule, generateCode, builders, MagicastError } from "magicast";
+var MANUAL_SNIPPET = `import { svelteVitals } from '@svelte-vitals/vite';
+// add svelteVitals() to your \`plugins\` array`;
+function codemodViteConfig(existing) {
+  if (existing === void 0) {
+    return { status: "manual", snippet: MANUAL_SNIPPET };
+  }
+  try {
+    const mod = parseModule(existing);
+    const def = mod.exports.default;
+    const configObj = def?.$type === "function-call" ? def.$args[0] : def;
+    if (!configObj || configObj.$type !== "object" || configObj.plugins?.$type !== "array") {
+      return { status: "manual", snippet: MANUAL_SNIPPET };
+    }
+    const already = configObj.plugins.find(
+      (p2) => p2?.$type === "function-call" && p2?.$callee === "svelteVitals"
+    );
+    if (already !== void 0) {
+      return { status: "exists" };
+    }
+    if (!mod.imports.svelteVitals) {
+      mod.imports.$append({ imported: "svelteVitals", local: "svelteVitals", from: "@svelte-vitals/vite" });
+    }
+    configObj.plugins.unshift(builders.functionCall("svelteVitals"));
+    return { status: "added", content: generateCode(mod, { format: { objectCurlySpacing: true } }).code };
+  } catch (err) {
+    if (err instanceof MagicastError) {
+      return { status: "manual", snippet: MANUAL_SNIPPET };
+    }
+    throw err;
+  }
+}
+
+// src/install/codemod-hooks.ts
+import { parseModule as parseModule2, generateCode as generateCode2, builders as builders2, MagicastError as MagicastError2 } from "magicast";
+var FRESH_HANDLE = `import { svelteVitalsHandle } from '@svelte-vitals/vite/hooks';
+import { sequence } from '@sveltejs/kit/hooks';
+
+export const handle = sequence(svelteVitalsHandle());
+`;
+var MANUAL_SNIPPET2 = `import { svelteVitalsHandle } from '@svelte-vitals/vite/hooks';
+import { sequence } from '@sveltejs/kit/hooks';
+// wrap your existing \`handle\` in sequence(yourHandle, svelteVitalsHandle())`;
+function addImports(mod) {
+  if (!mod.imports.sequence) {
+    mod.imports.$append({ imported: "sequence", local: "sequence", from: "@sveltejs/kit/hooks" });
+  }
+  if (!mod.imports.svelteVitalsHandle) {
+    mod.imports.$append({
+      imported: "svelteVitalsHandle",
+      local: "svelteVitalsHandle",
+      from: "@svelte-vitals/vite/hooks"
+    });
+  }
+}
+function codemodHooksServer(existing) {
+  if (existing === void 0) {
+    return { status: "created", content: FRESH_HANDLE };
+  }
+  try {
+    const mod = parseModule2(existing);
+    const handle = mod.exports.handle;
+    if (handle === void 0) {
+      addImports(mod);
+      mod.exports.handle = builders2.functionCall("sequence", builders2.functionCall("svelteVitalsHandle"));
+      return {
+        status: "added",
+        content: generateCode2(mod, { format: { objectCurlySpacing: true, quote: "single" } }).code
+      };
+    }
+    if (handle.$type === "function-call" && handle.$callee === "sequence") {
+      const already = handle.$args.find(
+        (a) => a?.$type === "function-call" && a?.$callee === "svelteVitalsHandle"
+      );
+      if (already !== void 0) {
+        return { status: "exists" };
+      }
+      if (!mod.imports.svelteVitalsHandle) {
+        mod.imports.$append({
+          imported: "svelteVitalsHandle",
+          local: "svelteVitalsHandle",
+          from: "@svelte-vitals/vite/hooks"
+        });
+      }
+      handle.$args.push(builders2.functionCall("svelteVitalsHandle"));
+      return {
+        status: "added",
+        content: generateCode2(mod, { format: { objectCurlySpacing: true, quote: "single" } }).code
+      };
+    }
+    addImports(mod);
+    mod.exports.handle = builders2.functionCall("sequence", handle, builders2.functionCall("svelteVitalsHandle"));
+    return {
+      status: "updated",
+      content: generateCode2(mod, { format: { objectCurlySpacing: true, quote: "single" } }).code
+    };
+  } catch (err) {
+    if (err instanceof MagicastError2) {
+      return { status: "manual", snippet: MANUAL_SNIPPET2 };
+    }
+    throw err;
+  }
+}
+
+// src/install/package-manager.ts
+import { join as join2 } from "path";
+var LOCKFILE_TO_PM = {
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+function detectPackageManager(io) {
+  for (const [file, pm] of Object.entries(LOCKFILE_TO_PM)) {
+    if (io.readFile(join2(io.cwd, file)) !== void 0) return pm;
+  }
+  return "npm";
+}
+function hasVitePackage(io) {
+  const raw = io.readFile(join2(io.cwd, "package.json"));
+  if (raw === void 0) return false;
+  try {
+    const pkg = JSON.parse(raw);
+    return Boolean(pkg.dependencies?.["@svelte-vitals/vite"] || pkg.devDependencies?.["@svelte-vitals/vite"]);
+  } catch {
+    return false;
+  }
+}
+function installCommand(pm) {
+  const action = pm === "npm" ? "install" : "add";
+  return { command: pm, args: [action, "-D", "@svelte-vitals/vite"] };
+}
+
 // src/install/index.ts
-function planFor(client, scope, io, force) {
+function planForClient(client, scope, io, force) {
   const path = client.resolvePath(scope, io.cwd, io.home);
   const existing = io.readFile(path);
   const merged = client.format === "toml" ? mergeToml(existing, MCP_ENTRY, force) : mergeJson(existing, MCP_ENTRY, force);
-  return { client, scope, path, status: merged.status, content: merged.content };
+  return { id: client.id, label: client.label, scope, path, status: merged.status, content: merged.content };
+}
+function resolveCandidate(io, candidates) {
+  for (const rel of candidates) {
+    const path = join3(io.cwd, rel);
+    const content = io.readFile(path);
+    if (content !== void 0) return { path, content };
+  }
+  return { path: join3(io.cwd, candidates[0]), content: void 0 };
+}
+function planForVitePlugin(io) {
+  const { path, content } = resolveCandidate(io, ["vite.config.ts", "vite.config.js", "vite.config.mjs"]);
+  const result = codemodViteConfig(content);
+  return { id: "vite-plugin", label: viteTargetById("vite-plugin").label, path, ...result };
+}
+function planForDevOverlay(io) {
+  const { path, content } = resolveCandidate(io, ["src/hooks.server.ts", "src/hooks.server.js"]);
+  const result = codemodHooksServer(content);
+  return { id: "vite-dev-overlay", label: viteTargetById("vite-dev-overlay").label, path, ...result };
+}
+function indent(text) {
+  return text.split("\n").map((l) => `      ${l}`).join("\n");
+}
+function rowLine(r) {
+  const head = `  ${r.label}${r.scope ? ` (${r.scope})` : ""} \u2192 ${r.path}  [${r.status}]`;
+  return r.status === "manual" && r.snippet ? `${head}
+${indent(r.snippet)}` : head;
 }
 async function runInstall(flags, io, prompts) {
   let ids;
@@ -184,22 +415,33 @@ async function runInstall(flags, io, prompts) {
         return false;
       }
     };
-    const detected = CLIENTS.filter((c) => c.scopes.some((s) => configExists(c.resolvePath(s, io.cwd, io.home)))).map(
-      (c) => c.id
+    const detectedClients = CLIENTS.filter(
+      (c) => c.scopes.some((s) => configExists(c.resolvePath(s, io.cwd, io.home)))
+    ).map((c) => c.id);
+    const viteConfigExists = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].some(
+      (f) => configExists(join3(io.cwd, f))
     );
-    const picked = await prompts.selectClients(CLIENTS, detected);
+    const detected = [...detectedClients, ...viteConfigExists ? VITE_TARGETS.map((t) => t.id) : []];
+    const options = [
+      ...CLIENTS.map((c) => ({ id: c.id, label: c.label })),
+      ...VITE_TARGETS.map((t) => ({ id: t.id, label: t.label, hint: t.hint }))
+    ];
+    const picked = await prompts.selectClients(options, detected);
     if (picked === null) {
       io.log("Cancelled.");
       return 0;
     }
     ids = picked;
   } else {
-    io.errorLog("svelte-vitals: no TTY; pass --client <claude-code,cursor,codex> to install non-interactively.");
+    io.errorLog(
+      "svelte-vitals: no TTY; pass --client <claude-code,cursor,codex,vite-plugin,vite-dev-overlay> to install non-interactively."
+    );
     return 2;
   }
   const clients = ids.map(clientById).filter((c) => c !== void 0);
-  if (clients.length === 0) {
-    io.errorLog("svelte-vitals: no valid clients selected.");
+  const viteIds = ids.filter(isViteTargetId);
+  if (clients.length === 0 && viteIds.length === 0) {
+    io.errorLog("svelte-vitals: no valid clients or targets selected.");
     return 2;
   }
   const rows = [];
@@ -220,7 +462,7 @@ async function runInstall(flags, io, prompts) {
       scope = "project";
     }
     try {
-      rows.push(planFor(client, scope, io, flags.force ?? false));
+      rows.push(planForClient(client, scope, io, flags.force ?? false));
     } catch (err) {
       const path = client.resolvePath(scope, io.cwd, io.home);
       io.errorLog(
@@ -229,7 +471,10 @@ async function runInstall(flags, io, prompts) {
       return 2;
     }
   }
-  const planText = rows.map((r) => `  ${r.client.label} (${r.scope}) \u2192 ${r.path}  [${r.status}]`).join("\n");
+  for (const viteId of viteIds) {
+    rows.push(viteId === "vite-plugin" ? planForVitePlugin(io) : planForDevOverlay(io));
+  }
+  const planText = rows.map(rowLine).join("\n");
   io.log("Plan:");
   io.log(planText);
   if (flags.dryRun) {
@@ -244,41 +489,63 @@ async function runInstall(flags, io, prompts) {
     }
   }
   let hadFailure = false;
+  let viteWasWritten = false;
   for (const r of rows) {
     if (r.status === "exists") {
-      io.log(`= ${r.client.label}: already configured (${r.path}) \u2014 use --force to overwrite.`);
+      const hint = isViteTargetId(r.id) ? "" : " \u2014 use --force to overwrite";
+      io.log(`= ${r.label}: already configured (${r.path})${hint}.`);
+      continue;
+    }
+    if (r.status === "manual") {
+      io.log(`! ${r.label}: couldn't safely modify ${r.path} \u2014 add this by hand:
+${indent(r.snippet ?? "")}`);
       continue;
     }
     try {
-      io.writeFile(r.path, r.content);
-      io.log(`\u2713 ${r.client.label}: ${r.status} ${r.path}`);
+      io.writeFile(r.path, r.content ?? "");
+      io.log(`\u2713 ${r.label}: ${r.status} ${r.path}`);
+      if (isViteTargetId(r.id)) viteWasWritten = true;
     } catch (err) {
       hadFailure = true;
       io.errorLog(`svelte-vitals: failed to write ${r.path}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  if (viteWasWritten && io.runCommand && !hasVitePackage(io)) {
+    const pm = detectPackageManager(io);
+    const { command, args } = installCommand(pm);
+    io.log(`Installing @svelte-vitals/vite via ${pm}...`);
+    const code = io.runCommand(command, args, io.cwd);
+    if (code !== 0) {
+      io.errorLog(
+        `svelte-vitals: failed to install @svelte-vitals/vite (${command} ${args.join(" ")} exited ${code}). Install it manually.`
+      );
+    }
+  }
   if (hadFailure) return 2;
   io.log("");
-  io.log("Done. Restart your client to load the svelte-vitals MCP server.");
+  if (clients.length > 0) io.log("Restart your client to load the svelte-vitals MCP server.");
+  if (viteWasWritten) io.log("Restart `vite dev` (or your build) to pick up the change.");
+  io.log("Done.");
   return 0;
 }
 
 // src/install/args.ts
-var VALID_CLIENTS = CLIENTS.map((c) => c.id);
+var VALID_TARGETS = [...CLIENTS.map((c) => c.id), ...VITE_TARGETS.map((t) => t.id)];
+var EXPECTED_TARGETS = VALID_TARGETS.join("|");
 function resolveInstallArgs(argv) {
   const warnings = [];
   const errors = [];
   const rawClients = typeof argv.client === "string" ? argv.client.split(",").map((s) => s.trim()).filter(Boolean) : [];
   const client = [];
   for (const c of rawClients) {
-    if (VALID_CLIENTS.includes(c)) {
+    if (VALID_TARGETS.includes(c)) {
       if (!client.includes(c)) client.push(c);
     } else {
-      warnings.push(`svelte-vitals: unknown --client '${c}'; expected claude-code|cursor|codex. Skipping.`);
+      warnings.push(`svelte-vitals: unknown --client '${c}'; expected ${EXPECTED_TARGETS}. Skipping.`);
     }
   }
   if (rawClients.length > 0 && client.length === 0) {
-    errors.push("svelte-vitals: no valid --client values; expected claude-code|cursor|codex.");
+    errors.push(`svelte-vitals: no valid --client values; expected ${EXPECTED_TARGETS}.`);
   }
   let scope;
   const rawScope = argv.scope;
@@ -307,7 +574,10 @@ Usage:
   svelte-vitals install [options]
 
 Options:
-  --client <ids>    Comma-separated: claude-code,cursor,codex (skips the interactive picker)
+  --client <ids>    Comma-separated: claude-code,cursor,codex,vite-plugin,vite-dev-overlay (skips the interactive picker)
+                    vite-plugin registers the build-mode plugin in vite.config.{ts,js,mjs}; vite-dev-overlay
+                    wires up the dev-overlay hook in src/hooks.server.{ts,js}. --force does not apply
+                    to either \u2014 an existing registration is always left as-is.
   --scope <scope>   project | global (applies to all selected clients; codex is always global)
   --yes, -y         Skip the confirmation prompt
   --dry-run         Print the planned changes and exit without writing
@@ -331,15 +601,32 @@ function realIO() {
     home: homedir(),
     isTTY: Boolean(process.stdout.isTTY),
     log: (line) => console.log(line),
-    errorLog: (line) => console.error(line)
+    errorLog: (line) => console.error(line),
+    runCommand: (command, args, cwd) => {
+      const result = spawnSync(command, args, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        timeout: 12e4
+      });
+      if (result.error) {
+        console.error(`svelte-vitals: ${command} failed to start: ${result.error.message}`);
+        return 1;
+      }
+      if (result.signal) {
+        console.error(`svelte-vitals: ${command} was terminated (${result.signal}) \u2014 it may have timed out.`);
+        return 1;
+      }
+      return result.status ?? 1;
+    }
   };
 }
 function clackPrompts() {
   return {
     selectClients: async (all, defaults) => {
       const res = await p.multiselect({
-        message: "Which clients should svelte-vitals be installed for?",
-        options: all.map((c) => ({ value: c.id, label: c.label })),
+        message: "Which clients/targets should svelte-vitals be installed for?",
+        options: all.map((o) => ({ value: o.id, label: o.label, hint: o.hint })),
         initialValues: defaults,
         required: true
       });
@@ -399,10 +686,14 @@ Options:
   --min-health <0-100>        Fail (exit 1) when the combined Health score is below this value
   --rules <ids>               Comma-separated rule ids to enable (all others disabled)
   --ignore <ids>              Comma-separated rule ids to disable
+  --weights <pairs>           Per-category Health weight overrides, e.g. seo=2,performance=1 (unlisted categories default to 1)
   --no-color                  Disable ANSI color in console output
   -h, --help                  Show this help
   -v, --version               Show version
 
+Config file:
+  svelte-vitals.config.{mjs,js,ts} in the analyzed directory; flags override it.
+
 Exit codes:
   0  no failing findings
   1  critical finding present (or --fail-on threshold reached)
@@ -427,7 +718,8 @@ async function main() {
       "ignore",
       "min-health",
       "out-file",
-      "diff"
+      "diff",
+      "weights"
     ]
   });
   if (argv.help) {