svelte-vitals 0.18.0 → 0.20.0

package/dist/bin.js

@@ -6,12 +6,76 @@ import {
   knownRuleIds,
   readPackageVersion,
   run
-} from "./chunk-NLQZ3CMZ.js";
+} from "./chunk-AAM2A7D7.js";
 
 // src/bin.ts
-import mri2 from "mri";
+import mri3 from "mri";
+import * as p2 from "@clack/prompts";
 
 // 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;
+}
+function parseCategories(raw, errors) {
+  if (typeof raw !== "string" || raw.trim() === "") return void 0;
+  const categories = [];
+  const unknownCategories = [];
+  for (const entry of raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)) {
+    if (!CATEGORIES.includes(entry)) {
+      unknownCategories.push(entry);
+      continue;
+    }
+    if (!categories.includes(entry)) categories.push(entry);
+  }
+  if (unknownCategories.length > 0) {
+    errors.push(`svelte-vitals: unknown category(ies) in --category: ${unknownCategories.join(", ")}`);
+    errors.push(`Known categories: ${CATEGORIES.join(", ")}`);
+  }
+  if (unknownCategories.length === 0 && categories.length === 0) {
+    errors.push("svelte-vitals: --category was passed but contains no categories.");
+  }
+  return categories;
+}
 var toList = (v) => typeof v === "string" ? v.split(",").map((s) => s.trim()).filter(Boolean) : [];
 function resolveArgs(argv) {
   const warnings = [];
@@ -28,6 +92,14 @@ function resolveArgs(argv) {
   const route = typeof argv.route === "string" ? argv.route : void 0;
   const diffBase = typeof argv.diff === "string" ? argv.diff || "HEAD" : void 0;
   const staged = Boolean(argv.staged);
+  let baselineRef;
+  if (typeof argv.baseline === "string") {
+    if (argv.baseline.trim() === "") {
+      errors.push("svelte-vitals: --baseline requires a git ref (e.g. --baseline origin/main).");
+    } else {
+      baselineRef = argv.baseline;
+    }
+  }
   const allow = toList(argv.rules);
   const ignore = toList(argv.ignore);
   const unknown = findUnknownRuleIds([...allow, ...ignore]);
@@ -41,7 +113,7 @@ function resolveArgs(argv) {
   } else if (typeof argv.reporter === "string") {
     if (!isReporterName(argv.reporter)) {
       errors.push(
-        `svelte-vitals: unknown reporter '${argv.reporter}'. Valid values: console, json, agent, sarif, github, html.`
+        `svelte-vitals: unknown reporter '${argv.reporter}'. Valid values: console, json, agent, sarif, github, html, md.`
       );
     } else {
       reporter = argv.reporter;
@@ -55,10 +127,21 @@ function resolveArgs(argv) {
     );
   }
   const failOn = argv["fail-on-warning"] ? "warning" : failOnValid ? failOnRaw : void 0;
+  const weights = parseWeights(argv.weights, errors);
+  const categories = parseCategories(argv.category, errors);
+  const score = Boolean(argv.score);
+  if (score && (argv.json || typeof argv.reporter === "string")) {
+    warnings.push("svelte-vitals: --score overrides --reporter; reporter output suppressed.");
+  }
+  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: {
       cwd: positional ?? process.cwd(),
+      // Never reinterpret an explicit target (design doc 2026-07-08-monorepo-app-picker-design.md,
+      // decision 1): the monorepo picker in run() only triggers when this is false.
+      explicitPath: positional !== void 0,
       metaComponents,
       treatDynamicAs,
       route,
@@ -66,9 +149,13 @@ 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 } : {},
+      ...categories !== void 0 ? { categories } : {},
+      ...score ? { score } : {},
       ...diffBase !== void 0 ? { diffBase } : {},
-      ...staged ? { staged } : {}
+      ...staged ? { staged } : {},
+      ...baselineRef !== void 0 ? { baseline: baselineRef } : {}
     },
     warnings,
     errors
@@ -189,6 +276,93 @@ function isViteTargetId(id) {
   return VITE_TARGETS.some((t) => t.id === id);
 }
 
+// src/install/agent-targets.ts
+var AGENT_TARGETS = [
+  {
+    id: "claude-skill",
+    label: "Claude Code skill",
+    hint: "Teaches the agent svelte-vitals rules + when to run the scanner",
+    relPath: ".claude/skills/svelte-vitals/SKILL.md"
+  },
+  {
+    id: "cursor-rules",
+    label: "Cursor rules",
+    hint: "Project rules file so Cursor avoids flagged patterns up front",
+    relPath: ".cursor/rules/svelte-vitals.mdc"
+  }
+];
+function agentTargetById(id) {
+  return AGENT_TARGETS.find((t) => t.id === id);
+}
+function isAgentTargetId(id) {
+  return AGENT_TARGETS.some((t) => t.id === id);
+}
+
+// src/install/skill-content.ts
+import { allRules, docsUrlFor } from "@svelte-vitals/core";
+var CATEGORY_ORDER = ["seo", "performance", "correctness", "security", "architecture"];
+var CATEGORY_LABELS = {
+  seo: "SEO",
+  performance: "Performance",
+  correctness: "Correctness",
+  security: "Security",
+  architecture: "Architecture"
+};
+function oneLine(text) {
+  return text.replace(/\r?\n+/g, " ").trim();
+}
+function ruleLine(rule) {
+  const fixPart = rule.fix?.description ? ` Fix: ${oneLine(rule.fix.description)}` : "";
+  return `- **${rule.id} \u2014 ${oneLine(rule.title)}** (${rule.severity}): ${oneLine(rule.rationale)}${fixPart} ([docs](${docsUrlFor(rule.id)}))`;
+}
+function ruleDigest() {
+  return CATEGORY_ORDER.map((category) => {
+    const lines = allRules.filter((r) => r.category === category).map(ruleLine).join("\n");
+    return `### ${CATEGORY_LABELS[category]}
+
+${lines}`;
+  }).join("\n\n");
+}
+function sharedBody(version) {
+  return `<!-- Generated by \`svelte-vitals install\` (svelte-vitals ${version}). Re-run with --force to refresh. -->
+
+# svelte-vitals
+
+## When to use
+
+Use this whenever you are writing or reviewing SvelteKit route files (\`+page.svelte\`, \`+layout.svelte\`) or components in this project \u2014 svelte-vitals statically checks SEO, performance, correctness, security, and architecture patterns.
+
+## Playbook
+
+1. After writing or editing code, run \`npx svelte-vitals . --diff --reporter agent\` and fix any findings it reports.
+2. Before committing, run \`npx svelte-vitals . --staged\` as a pre-commit gate.
+3. For a rule's full rationale and fix examples, use the \`explain_rule\` MCP tool (svelte-vitals MCP server) or open its docs link below.
+
+## Rule digest
+
+${ruleDigest()}
+`;
+}
+function buildSkillMarkdown(version) {
+  const frontmatter = `---
+name: svelte-vitals
+description: Use when writing or reviewing SvelteKit routes/components \u2014 svelte-vitals rule knowledge (SEO, performance, correctness, security, architecture) and how to run the scanner.
+---`;
+  return `${frontmatter}
+
+${sharedBody(version)}`;
+}
+function buildCursorRules(version) {
+  const frontmatter = `---
+description: svelte-vitals code-health rules for SvelteKit (SEO, performance, correctness, security, architecture)
+globs: ["**/*.svelte", "src/routes/**"]
+alwaysApply: false
+---`;
+  return `${frontmatter}
+
+${sharedBody(version)}`;
+}
+
 // src/install/codemod-vite-config.ts
 import { parseModule, generateCode, builders, MagicastError } from "magicast";
 var MANUAL_SNIPPET = `import { svelteVitals } from '@svelte-vitals/vite';
@@ -205,7 +379,7 @@ function codemodViteConfig(existing) {
       return { status: "manual", snippet: MANUAL_SNIPPET };
     }
     const already = configObj.plugins.find(
-      (p2) => p2?.$type === "function-call" && p2?.$callee === "svelteVitals"
+      (p3) => p3?.$type === "function-call" && p3?.$callee === "svelteVitals"
     );
     if (already !== void 0) {
       return { status: "exists" };
@@ -348,6 +522,13 @@ function planForDevOverlay(io) {
   const result = codemodHooksServer(content);
   return { id: "vite-dev-overlay", label: viteTargetById("vite-dev-overlay").label, path, ...result };
 }
+function planForAgentTarget(target, io, force, version) {
+  const path = join3(io.cwd, target.relPath);
+  const existing = io.readFile(path);
+  const content = target.id === "claude-skill" ? buildSkillMarkdown(version) : buildCursorRules(version);
+  const status = existing === void 0 ? "created" : force ? "updated" : "exists";
+  return { id: target.id, label: target.label, path, status, content };
+}
 function indent(text) {
   return text.split("\n").map((l) => `      ${l}`).join("\n");
 }
@@ -356,7 +537,7 @@ function rowLine(r) {
   return r.status === "manual" && r.snippet ? `${head}
 ${indent(r.snippet)}` : head;
 }
-async function runInstall(flags, io, prompts) {
+async function runInstall(flags, io, prompts, version = "0.0.0") {
   let ids;
   if (flags.client && flags.client.length > 0) {
     ids = flags.client;
@@ -374,10 +555,21 @@ async function runInstall(flags, io, prompts) {
     const viteConfigExists = ["vite.config.ts", "vite.config.js", "vite.config.mjs"].some(
       (f) => configExists(join3(io.cwd, f))
     );
-    const detected = [...detectedClients, ...viteConfigExists ? VITE_TARGETS.map((t) => t.id) : []];
+    const claudeSkillDetected = configExists(join3(io.cwd, ".claude", "settings.json"));
+    const cursorRulesDetected = configExists(join3(io.cwd, ".cursor", "mcp.json"));
+    const detectedAgents = [
+      ...claudeSkillDetected ? ["claude-skill"] : [],
+      ...cursorRulesDetected ? ["cursor-rules"] : []
+    ];
+    const detected = [
+      ...detectedClients,
+      ...viteConfigExists ? VITE_TARGETS.map((t) => t.id) : [],
+      ...detectedAgents
+    ];
     const options = [
       ...CLIENTS.map((c) => ({ id: c.id, label: c.label })),
-      ...VITE_TARGETS.map((t) => ({ id: t.id, label: t.label, hint: t.hint }))
+      ...VITE_TARGETS.map((t) => ({ id: t.id, label: t.label, hint: t.hint })),
+      ...AGENT_TARGETS.map((t) => ({ id: t.id, label: t.label, hint: t.hint }))
     ];
     const picked = await prompts.selectClients(options, detected);
     if (picked === null) {
@@ -387,13 +579,14 @@ async function runInstall(flags, io, prompts) {
     ids = picked;
   } else {
     io.errorLog(
-      "svelte-vitals: no TTY; pass --client <claude-code,cursor,codex,vite-plugin,vite-dev-overlay> to install non-interactively."
+      "svelte-vitals: no TTY; pass --client <claude-code,cursor,codex,vite-plugin,vite-dev-overlay,claude-skill,cursor-rules> to install non-interactively."
     );
     return 2;
   }
   const clients = ids.map(clientById).filter((c) => c !== void 0);
   const viteIds = ids.filter(isViteTargetId);
-  if (clients.length === 0 && viteIds.length === 0) {
+  const agentIds = ids.filter(isAgentTargetId);
+  if (clients.length === 0 && viteIds.length === 0 && agentIds.length === 0) {
     io.errorLog("svelte-vitals: no valid clients or targets selected.");
     return 2;
   }
@@ -427,6 +620,10 @@ async function runInstall(flags, io, prompts) {
   for (const viteId of viteIds) {
     rows.push(viteId === "vite-plugin" ? planForVitePlugin(io) : planForDevOverlay(io));
   }
+  for (const agentId of agentIds) {
+    const target = agentTargetById(agentId);
+    rows.push(planForAgentTarget(target, io, flags.force ?? false, version));
+  }
   const planText = rows.map(rowLine).join("\n");
   io.log("Plan:");
   io.log(planText);
@@ -483,7 +680,11 @@ ${indent(r.snippet ?? "")}`);
 }
 
 // src/install/args.ts
-var VALID_TARGETS = [...CLIENTS.map((c) => c.id), ...VITE_TARGETS.map((t) => t.id)];
+var VALID_TARGETS = [
+  ...CLIENTS.map((c) => c.id),
+  ...VITE_TARGETS.map((t) => t.id),
+  ...AGENT_TARGETS.map((t) => t.id)
+];
 var EXPECTED_TARGETS = VALID_TARGETS.join("|");
 function resolveInstallArgs(argv) {
   const warnings = [];
@@ -521,16 +722,20 @@ function resolveInstallArgs(argv) {
 }
 
 // src/install/cli.ts
-var INSTALL_HELP = `svelte-vitals install \u2014 set up the svelte-vitals MCP server for your AI-agent clients
+var INSTALL_HELP = `svelte-vitals install \u2014 set up the svelte-vitals MCP server, Vite integration, and agent skills/rules
 
 Usage:
   svelte-vitals install [options]
 
 Options:
-  --client <ids>    Comma-separated: claude-code,cursor,codex,vite-plugin,vite-dev-overlay (skips the interactive picker)
+  --client <ids>    Comma-separated: claude-code,cursor,codex,vite-plugin,vite-dev-overlay,claude-skill,cursor-rules
+                    (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.
+                    to either of these two \u2014 an existing registration is always left as-is.
+                    claude-skill writes a Claude Code skill (.claude/skills/svelte-vitals/SKILL.md); cursor-rules
+                    writes a Cursor rules file (.cursor/rules/svelte-vitals.mdc). Both are generated from the
+                    current rule set and support --force to regenerate.
   --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
@@ -614,7 +819,143 @@ async function runInstallCli(args) {
   for (const w of warnings) console.error(w);
   for (const e of errors) console.error(e);
   if (!flags) return 2;
-  return runInstall(flags, realIO(), clackPrompts());
+  return runInstall(flags, realIO(), clackPrompts(), readPackageVersion());
+}
+
+// src/ci/cli.ts
+import { join as join4 } from "path";
+import mri2 from "mri";
+
+// src/ci/workflow.ts
+var WORKFLOW_PATH = ".github/workflows/svelte-vitals.yml";
+function planWorkflowWrite(existing, force) {
+  if (existing === void 0) return { status: "created" };
+  if (!force) return { status: "exists" };
+  return { status: "updated" };
+}
+function buildWorkflowYaml(opts) {
+  const v = opts.version;
+  return [
+    `# Generated by \`svelte-vitals ci install\` (svelte-vitals ${v}).`,
+    "# Re-run with --force to regenerate.",
+    "name: svelte-vitals",
+    "",
+    "on:",
+    "  pull_request:",
+    "",
+    "permissions:",
+    "  contents: read",
+    "  pull-requests: write",
+    "",
+    "jobs:",
+    "  svelte-vitals:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    "      - uses: actions/checkout@v4",
+    "        with:",
+    "          fetch-depth: 0",
+    "      - uses: actions/setup-node@v4",
+    "        with:",
+    "          node-version: 24",
+    "      - name: Scan (inline annotations + gate)",
+    "        id: scan",
+    "        continue-on-error: true",
+    "        run: >",
+    `          npx -y svelte-vitals@${v} .`,
+    "          --diff origin/${{ github.base_ref }}",
+    "          --baseline origin/${{ github.base_ref }}",
+    "          --reporter github",
+    "      - name: Markdown summary",
+    "        run: >",
+    `          npx -y svelte-vitals@${v} .`,
+    "          --diff origin/${{ github.base_ref }}",
+    "          --baseline origin/${{ github.base_ref }}",
+    "          --reporter md > svelte-vitals-report.md || true",
+    "      - name: Job summary",
+    '        run: cat svelte-vitals-report.md >> "$GITHUB_STEP_SUMMARY"',
+    "      - name: PR comment (sticky)",
+    "        if: github.event.pull_request.head.repo.full_name == github.repository",
+    "        continue-on-error: true",
+    "        uses: actions/github-script@v7",
+    "        with:",
+    "          script: |",
+    "            const fs = require('fs');",
+    "            const marker = '<!-- svelte-vitals-report -->';",
+    "            const body = marker + '\\n' + fs.readFileSync('svelte-vitals-report.md', 'utf8');",
+    "            const { data: comments } = await github.rest.issues.listComments({",
+    "              ...context.repo, issue_number: context.issue.number, per_page: 100",
+    "            });",
+    "            const mine = comments.find(c => c.body && c.body.startsWith(marker));",
+    "            if (mine) {",
+    "              await github.rest.issues.updateComment({ ...context.repo, comment_id: mine.id, body });",
+    "            } else {",
+    "              await github.rest.issues.createComment({ ...context.repo, issue_number: context.issue.number, body });",
+    "            }",
+    "      - name: Gate",
+    "        if: steps.scan.outcome == 'failure'",
+    "        run: |",
+    '          echo "svelte-vitals found blocking issues (see annotations above)."',
+    "          exit 1",
+    ""
+  ].join("\n");
+}
+
+// src/ci/cli.ts
+var CI_HELP = `svelte-vitals ci \u2014 scaffold CI integration
+
+Usage:
+  svelte-vitals ci install [options]
+
+Adds a GitHub Actions workflow (${WORKFLOW_PATH}) that scans pull requests, posts inline
+annotations + a job summary, and maintains a sticky PR comment with the findings.
+
+Options:
+  --force       Overwrite an existing workflow file
+  --dry-run     Print the plan and exit without writing
+  -h, --help    Show this help`;
+async function runCiCli(args, io = realIO()) {
+  const sub = args[0];
+  if (sub === "--help" || sub === "-h") {
+    io.log(CI_HELP);
+    return 0;
+  }
+  if (sub !== "install") {
+    io.log(CI_HELP);
+    return 2;
+  }
+  const argv = mri2(args.slice(1), {
+    boolean: ["force", "dry-run", "help"],
+    alias: { h: "help" }
+  });
+  if (argv.help) {
+    io.log(CI_HELP);
+    return 0;
+  }
+  const path = join4(io.cwd, WORKFLOW_PATH);
+  const existing = io.readFile(path);
+  const plan = planWorkflowWrite(existing, Boolean(argv.force));
+  io.log("Plan:");
+  io.log(`  ${WORKFLOW_PATH}  [${plan.status}]`);
+  if (argv["dry-run"]) {
+    io.log("Dry run \u2014 no files written.");
+    return 0;
+  }
+  if (plan.status === "exists") {
+    io.log(`= already installed (${WORKFLOW_PATH}) \u2014 use --force to regenerate.`);
+  } else {
+    const version = readPackageVersion();
+    try {
+      io.writeFile(path, buildWorkflowYaml({ version }));
+      io.log(`\u2713 ${plan.status} ${WORKFLOW_PATH}`);
+    } catch (err) {
+      io.errorLog(
+        `svelte-vitals: failed to write ${WORKFLOW_PATH}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return 2;
+    }
+  }
+  io.log("Done. Commit the workflow file and open a PR to see it in action.");
+  return 0;
 }
 
 // src/bin.ts
@@ -622,7 +963,8 @@ var HELP = `svelte-vitals \u2014 a deterministic SvelteKit code-health scanner (
 
 Usage:
   svelte-vitals [path] [options]
-  svelte-vitals install          Set up the MCP server for Claude Code / Cursor / Codex
+  svelte-vitals install          Set up the MCP server, Vite integration, or agent skills/rules
+  svelte-vitals ci install       Add a GitHub Actions PR gate (annotations + summary comment)
 
 Options:
   --meta-components <names>   Comma-separated component names that emit head metadata
@@ -630,8 +972,9 @@ Options:
   --route <glob>              Only analyze routes matching this glob
   --diff [ref]                Report only findings in files changed vs ref (default HEAD; e.g. --diff main)
   --staged                    Report only findings in files staged for commit (pre-commit gate)
+  --baseline <ref>            Report only findings not present at ref (compare against e.g. origin/main)
   --by-route                  Show per-route score breakdown in console output
-  --reporter <fmt>            console | json | agent | sarif | github | html (auto: agent under AI-agent envs, github under GitHub Actions)
+  --reporter <fmt>            console | json | agent | sarif | github | html | md (auto: agent under AI-agent envs, github under GitHub Actions)
   --out-file <path>           Output path for --reporter html (default: svelte-vitals-report.html; '-' for stdout)
   --json                      Alias for --reporter=json
   --fail-on <severity>        Fail (exit 1) when any finding reaches this severity: critical | warning | info
@@ -639,24 +982,41 @@ 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
+  --category <cats>           Comma-separated categories to analyze: seo | performance | correctness | security | architecture
+  --weights <pairs>           Per-category Health weight overrides, e.g. seo=2,performance=1 (unlisted categories default to 1)
+  --score                     Print only the combined Health score (works with --min-health for gating)
   --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)
   2  execution error (not a SvelteKit project / internal error)`;
 var VERSION = readPackageVersion();
+async function selectApp(apps) {
+  const res = await p2.select({
+    message: "Multiple SvelteKit apps found \u2014 which one should svelte-vitals analyze?",
+    options: apps.map((a) => ({ value: a, label: a }))
+  });
+  return p2.isCancel(res) ? null : res;
+}
 async function main() {
   const rawArgs = process.argv.slice(2);
   if (rawArgs[0] === "install") {
     const code2 = await runInstallCli(rawArgs.slice(1));
     process.exit(code2);
   }
-  const argv = mri2(process.argv.slice(2), {
+  if (rawArgs[0] === "ci") {
+    const code2 = await runCiCli(rawArgs.slice(1));
+    process.exit(code2);
+  }
+  const argv = mri3(process.argv.slice(2), {
     alias: { h: "help", v: "version" },
-    boolean: ["by-route", "json", "fail-on-warning", "staged", "no-color"],
+    boolean: ["by-route", "json", "fail-on-warning", "staged", "no-color", "score"],
     string: [
       "meta-components",
       "treat-dynamic-as",
@@ -667,7 +1027,10 @@ async function main() {
       "ignore",
       "min-health",
       "out-file",
-      "diff"
+      "diff",
+      "baseline",
+      "weights",
+      "category"
     ]
   });
   if (argv.help) {
@@ -692,7 +1055,7 @@ async function main() {
     }
     minHealth = n;
   }
-  const code = await run({ ...options, minHealth, noColor: argv["no-color"] });
+  const code = await run({ ...options, minHealth, noColor: argv["no-color"], selectApp });
   process.exit(code);
 }
 void main();