indxel-cli 0.3.1 → 0.4.0

package/dist/bin.js

@@ -7,9 +7,10 @@ import { Command as Command8 } from "commander";
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { existsSync as existsSync3 } from "fs";
-import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
+import { createInterface } from "readline";
 
 // src/detect.ts
 import { existsSync } from "fs";
@@ -18,6 +19,7 @@ import { join } from "path";
 async function detectProject(cwd) {
   const info = {
     root: cwd,
+    framework: "unknown",
     isNextJs: false,
     usesAppRouter: false,
     appDir: "app",
@@ -26,6 +28,19 @@ async function detectProject(cwd) {
     hasSitemap: false,
     hasRobots: false
   };
+  info.isTypeScript = existsSync(join(cwd, "tsconfig.json")) || existsSync(join(cwd, "tsconfig.ts"));
+  let pkg = null;
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    } catch {
+    }
+  }
+  const deps = {
+    ...pkg?.dependencies,
+    ...pkg?.devDependencies
+  };
   const nextConfigs = [
     "next.config.ts",
     "next.config.js",
@@ -33,31 +48,93 @@ async function detectProject(cwd) {
     "next.config.cjs"
   ];
   info.isNextJs = nextConfigs.some((f) => existsSync(join(cwd, f)));
-  const pkgPath = join(cwd, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
-      const nextDep = pkg.dependencies?.next ?? pkg.devDependencies?.next;
-      if (nextDep) {
-        info.isNextJs = true;
-        info.nextVersion = nextDep.replace(/[\^~>=<]/g, "").trim();
+  if (deps.next) {
+    info.isNextJs = true;
+    info.nextVersion = deps.next.replace(/[\^~>=<]/g, "").trim();
+  }
+  if (info.isNextJs) {
+    info.framework = "nextjs";
+    info.frameworkVersion = info.nextVersion;
+    if (existsSync(join(cwd, "src", "app"))) {
+      info.usesAppRouter = true;
+      info.appDir = "src/app";
+    } else if (existsSync(join(cwd, "app"))) {
+      info.usesAppRouter = true;
+      info.appDir = "app";
+    }
+  }
+  if (!info.isNextJs) {
+    const nuxtConfigs = ["nuxt.config.ts", "nuxt.config.js"];
+    const hasNuxtConfig = nuxtConfigs.some((f) => existsSync(join(cwd, f)));
+    if (hasNuxtConfig || deps.nuxt) {
+      info.framework = "nuxt";
+      info.frameworkVersion = deps.nuxt?.replace(/[\^~>=<]/g, "").trim();
+      if (existsSync(join(cwd, "pages"))) {
+        info.usesAppRouter = true;
+        info.appDir = "pages";
       }
-    } catch {
     }
   }
-  info.isTypeScript = existsSync(join(cwd, "tsconfig.json")) || existsSync(join(cwd, "tsconfig.ts"));
-  if (existsSync(join(cwd, "src", "app"))) {
-    info.usesAppRouter = true;
-    info.appDir = "src/app";
-  } else if (existsSync(join(cwd, "app"))) {
-    info.usesAppRouter = true;
-    info.appDir = "app";
+  if (info.framework === "unknown") {
+    const remixDep = deps["@remix-run/react"] ?? deps["@remix-run/node"] ?? deps["@remix-run/cloudflare"];
+    const hasRemixConfig = existsSync(join(cwd, "remix.config.js")) || existsSync(join(cwd, "remix.config.ts"));
+    if (hasRemixConfig || remixDep) {
+      info.framework = "remix";
+      info.frameworkVersion = remixDep?.replace(/[\^~>=<]/g, "").trim();
+      if (existsSync(join(cwd, "app", "routes"))) {
+        info.usesAppRouter = true;
+        info.appDir = "app/routes";
+      } else if (existsSync(join(cwd, "app"))) {
+        info.usesAppRouter = true;
+        info.appDir = "app";
+      }
+    }
+  }
+  if (info.framework === "unknown") {
+    const astroConfigs = ["astro.config.mjs", "astro.config.ts", "astro.config.js"];
+    const hasAstroConfig = astroConfigs.some((f) => existsSync(join(cwd, f)));
+    if (hasAstroConfig || deps.astro) {
+      info.framework = "astro";
+      info.frameworkVersion = deps.astro?.replace(/[\^~>=<]/g, "").trim();
+      if (existsSync(join(cwd, "src", "pages"))) {
+        info.usesAppRouter = true;
+        info.appDir = "src/pages";
+      }
+    }
+  }
+  if (info.framework === "unknown") {
+    const hasSvelteConfig = existsSync(join(cwd, "svelte.config.js")) || existsSync(join(cwd, "svelte.config.ts"));
+    if (hasSvelteConfig && deps["@sveltejs/kit"] || deps["@sveltejs/kit"]) {
+      info.framework = "sveltekit";
+      info.frameworkVersion = deps["@sveltejs/kit"]?.replace(/[\^~>=<]/g, "").trim();
+      if (existsSync(join(cwd, "src", "routes"))) {
+        info.usesAppRouter = true;
+        info.appDir = "src/routes";
+      }
+    }
   }
   info.hasSeoConfig = existsSync(join(cwd, "seo.config.ts")) || existsSync(join(cwd, "seo.config.js"));
-  info.hasSitemap = existsSync(join(cwd, info.appDir, "sitemap.ts")) || existsSync(join(cwd, info.appDir, "sitemap.js")) || existsSync(join(cwd, info.appDir, "sitemap.xml"));
-  info.hasRobots = existsSync(join(cwd, info.appDir, "robots.ts")) || existsSync(join(cwd, info.appDir, "robots.js")) || existsSync(join(cwd, info.appDir, "robots.txt"));
+  const sitemapDirs = info.framework === "nextjs" ? [info.appDir] : [info.appDir, "public", "."];
+  const robotsDirs = info.framework === "nextjs" ? [info.appDir] : [info.appDir, "public", "."];
+  info.hasSitemap = sitemapDirs.some(
+    (dir) => existsSync(join(cwd, dir, "sitemap.ts")) || existsSync(join(cwd, dir, "sitemap.js")) || existsSync(join(cwd, dir, "sitemap.xml"))
+  );
+  info.hasRobots = robotsDirs.some(
+    (dir) => existsSync(join(cwd, dir, "robots.ts")) || existsSync(join(cwd, dir, "robots.js")) || existsSync(join(cwd, dir, "robots.txt"))
+  );
   return info;
 }
+function frameworkLabel(fw) {
+  const labels = {
+    nextjs: "Next.js",
+    nuxt: "Nuxt",
+    remix: "Remix",
+    astro: "Astro",
+    sveltekit: "SvelteKit",
+    unknown: "Unknown"
+  };
+  return labels[fw];
+}
 
 // src/store.ts
 import { existsSync as existsSync2 } from "fs";
@@ -159,13 +236,13 @@ async function resolveApiKey(explicit) {
 }
 
 // src/templates.ts
-function seoConfigTemplate(isTypeScript) {
+function seoConfigTemplate(isTypeScript, siteUrl = "https://example.com") {
   if (isTypeScript) {
     return `import { defineSEO } from 'indxel'
 
 export default defineSEO({
   siteName: 'My Site',
-  siteUrl: 'https://example.com',
+  siteUrl: '${siteUrl}',
   titleTemplate: '%s | My Site',
   defaultDescription: 'A short description of your site for search engines.',
   defaultOGImage: '/og-image.png',
@@ -177,7 +254,7 @@ export default defineSEO({
   // organization: {
   //   name: 'My Company',
   //   logo: '/logo.png',
-  //   url: 'https://example.com',
+  //   url: '${siteUrl}',
   // },
 })
 `;
@@ -186,7 +263,7 @@ export default defineSEO({
 
 module.exports = defineSEO({
   siteName: 'My Site',
-  siteUrl: 'https://example.com',
+  siteUrl: '${siteUrl}',
   titleTemplate: '%s | My Site',
   defaultDescription: 'A short description of your site for search engines.',
   defaultOGImage: '/og-image.png',
@@ -194,12 +271,12 @@ module.exports = defineSEO({
 })
 `;
 }
-function sitemapTemplate(isTypeScript) {
+function sitemapTemplate(isTypeScript, siteUrl = "https://example.com") {
   if (isTypeScript) {
     return `import type { MetadataRoute } from 'next'
 
 export default function sitemap(): MetadataRoute.Sitemap {
-  const baseUrl = 'https://example.com'
+  const baseUrl = '${siteUrl}'
 
   return [
     {
@@ -223,7 +300,7 @@ export default function sitemap(): MetadataRoute.Sitemap {
   }
   return `/** @returns {import('next').MetadataRoute.Sitemap} */
 export default function sitemap() {
-  const baseUrl = 'https://example.com'
+  const baseUrl = '${siteUrl}'
 
   return [
     {
@@ -236,12 +313,12 @@ export default function sitemap() {
 }
 `;
 }
-function robotsTemplate(isTypeScript) {
+function robotsTemplate(isTypeScript, siteUrl = "https://example.com") {
   if (isTypeScript) {
     return `import type { MetadataRoute } from 'next'
 
 export default function robots(): MetadataRoute.Robots {
-  const baseUrl = 'https://example.com'
+  const baseUrl = '${siteUrl}'
 
   return {
     rules: [
@@ -258,7 +335,7 @@ export default function robots(): MetadataRoute.Robots {
   }
   return `/** @returns {import('next').MetadataRoute.Robots} */
 export default function robots() {
-  const baseUrl = 'https://example.com'
+  const baseUrl = '${siteUrl}'
 
   return {
     rules: [
@@ -274,7 +351,233 @@ export default function robots() {
 `;
 }
 
+// src/config.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+var CONFIG_FILES = [".indxelrc.json", ".indxelrc", "indxel.config.json"];
+async function loadConfig(cwd) {
+  for (const file of CONFIG_FILES) {
+    const path = join3(cwd, file);
+    if (existsSync3(path)) {
+      try {
+        const content = await readFile3(path, "utf-8");
+        return JSON.parse(content);
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+var URL_ENV_VARS = {
+  // Framework-specific
+  nextjs: ["NEXT_PUBLIC_APP_URL", "NEXT_PUBLIC_SITE_URL", "NEXT_PUBLIC_BASE_URL", "NEXT_PUBLIC_URL"],
+  nuxt: ["NUXT_PUBLIC_SITE_URL", "NUXT_PUBLIC_APP_URL", "NUXT_SITE_URL"],
+  remix: ["APP_URL", "BASE_URL"],
+  astro: ["SITE_URL", "PUBLIC_SITE_URL", "ASTRO_SITE"],
+  sveltekit: ["PUBLIC_SITE_URL", "VITE_SITE_URL"],
+  // Generic (works for all)
+  generic: ["SITE_URL", "BASE_URL", "APP_URL", "DEPLOY_URL", "URL"]
+};
+async function detectProjectUrl(cwd, framework) {
+  const candidates = [];
+  const config = await loadConfig(cwd);
+  if (config.baseUrl) {
+    candidates.push({ url: normalize(config.baseUrl), source: ".indxelrc.json", weight: 10 });
+  }
+  for (const ext of ["ts", "js"]) {
+    const configPath = join3(cwd, `seo.config.${ext}`);
+    if (existsSync3(configPath)) {
+      try {
+        const content = await readFile3(configPath, "utf-8");
+        const match = content.match(/siteUrl\s*:\s*['"`]([^'"`]+)['"`]/);
+        if (match?.[1] && match[1] !== "https://example.com") {
+          candidates.push({ url: normalize(match[1]), source: `seo.config.${ext}`, weight: 10 });
+        }
+      } catch {
+      }
+    }
+  }
+  const envVars = [
+    ...framework && URL_ENV_VARS[framework] ? URL_ENV_VARS[framework] : [],
+    ...URL_ENV_VARS.generic
+  ];
+  const uniqueVars = [...new Set(envVars)];
+  const envFiles = [".env.production", ".env.production.local", ".env.local", ".env"];
+  for (const file of envFiles) {
+    const envPath = join3(cwd, file);
+    if (!existsSync3(envPath)) continue;
+    try {
+      const content = await readFile3(envPath, "utf-8");
+      for (const varName of uniqueVars) {
+        const match = content.match(new RegExp(`^${varName}\\s*=\\s*['"]?([^'"
+]+)['"]?`, "m"));
+        if (match?.[1]) {
+          const url = match[1].trim();
+          if (isProductionUrl(url)) {
+            const weight = file.includes("production") ? 7 : 5;
+            candidates.push({ url: normalize(url), source: `${file} (${varName})`, weight });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const fwUrl = await detectFromFrameworkConfig(cwd, framework);
+  if (fwUrl) {
+    candidates.push(fwUrl);
+  }
+  const vercelUrl = await detectFromVercel(cwd);
+  if (vercelUrl) {
+    candidates.push(vercelUrl);
+  }
+  const netlifyUrl = await detectFromNetlify(cwd);
+  if (netlifyUrl) {
+    candidates.push(netlifyUrl);
+  }
+  try {
+    const pkg = JSON.parse(await readFile3(join3(cwd, "package.json"), "utf-8"));
+    if (pkg.homepage && isProductionUrl(pkg.homepage)) {
+      candidates.push({ url: normalize(pkg.homepage), source: "package.json (homepage)", weight: 4 });
+    }
+  } catch {
+  }
+  if (candidates.length === 0) {
+    return { url: null, source: "", confident: false, all: [] };
+  }
+  const originCounts = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const origin = new URL(c.url).origin;
+    const existing = originCounts.get(origin);
+    if (!existing || c.weight > existing.best.weight) {
+      originCounts.set(origin, {
+        count: (existing?.count ?? 0) + 1,
+        best: c
+      });
+    } else {
+      existing.count++;
+    }
+  }
+  let best = null;
+  for (const [origin, data] of originCounts) {
+    const score = data.count * data.best.weight;
+    if (!best || score > best.count * best.best.weight) {
+      best = { origin, ...data };
+    }
+  }
+  const result = best.best;
+  const confident = result.weight >= 10 || best.count >= 2;
+  return {
+    url: result.url,
+    source: result.source,
+    confident,
+    all: candidates
+  };
+}
+async function resolveProjectUrl(cwd) {
+  const result = await detectProjectUrl(cwd);
+  return result.url;
+}
+function normalize(url) {
+  if (!url.startsWith("http")) url = `https://${url}`;
+  return url.replace(/\/+$/, "");
+}
+function isProductionUrl(url) {
+  if (!url || !url.startsWith("http")) return false;
+  if (url.includes("localhost")) return false;
+  if (url.includes("127.0.0.1")) return false;
+  if (url.includes("0.0.0.0")) return false;
+  return true;
+}
+async function detectFromFrameworkConfig(cwd, framework) {
+  if (!framework || framework === "astro") {
+    for (const file of ["astro.config.mjs", "astro.config.ts", "astro.config.js"]) {
+      const configPath = join3(cwd, file);
+      if (existsSync3(configPath)) {
+        try {
+          const content = await readFile3(configPath, "utf-8");
+          const match = content.match(/site\s*:\s*['"`]([^'"`]+)['"`]/);
+          if (match?.[1] && isProductionUrl(match[1])) {
+            return { url: normalize(match[1]), source: `${file} (site)`, weight: 8 };
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  if (!framework || framework === "nuxt") {
+    for (const file of ["nuxt.config.ts", "nuxt.config.js"]) {
+      const configPath = join3(cwd, file);
+      if (existsSync3(configPath)) {
+        try {
+          const content = await readFile3(configPath, "utf-8");
+          const match = content.match(/url\s*:\s*['"`]([^'"`]+)['"`]/);
+          if (match?.[1] && isProductionUrl(match[1])) {
+            return { url: normalize(match[1]), source: `${file} (site.url)`, weight: 8 };
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return null;
+}
+async function detectFromVercel(cwd) {
+  const vercelPath = join3(cwd, ".vercel", "project.json");
+  if (!existsSync3(vercelPath)) return null;
+  try {
+    const content = JSON.parse(await readFile3(vercelPath, "utf-8"));
+    if (content.projectName) {
+      return {
+        url: `https://${content.projectName}.vercel.app`,
+        source: ".vercel/project.json",
+        weight: 3
+        // Low weight — *.vercel.app is often not the real domain
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function detectFromNetlify(cwd) {
+  const tomlPath = join3(cwd, "netlify.toml");
+  if (existsSync3(tomlPath)) {
+    try {
+      const content = await readFile3(tomlPath, "utf-8");
+      const match = content.match(/URL\s*=\s*['"]([^'"]+)['"]/i);
+      if (match?.[1] && isProductionUrl(match[1])) {
+        return { url: normalize(match[1]), source: "netlify.toml", weight: 6 };
+      }
+    } catch {
+    }
+  }
+  const statePath = join3(cwd, ".netlify", "state.json");
+  if (existsSync3(statePath)) {
+    try {
+      const content = JSON.parse(await readFile3(statePath, "utf-8"));
+      if (content.siteId) {
+        return {
+          url: `https://${content.siteId}.netlify.app`,
+          source: ".netlify/state.json",
+          weight: 2
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
 // src/commands/init.ts
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
 var PRE_PUSH_HOOK = `#!/bin/sh
 # indxel SEO guard \u2014 blocks push if critical SEO errors are found
 echo "\\033[36m[indxel]\\033[0m Running SEO check before push..."
@@ -286,59 +589,84 @@ if [ $? -ne 0 ]; then
   exit 1
 fi
 `;
-var initCommand = new Command("init").description("Initialize indxel in your Next.js project").option("--cwd <path>", "Project directory", process.cwd()).option("--force", "Overwrite existing files", false).option("--hook", "Install git pre-push hook to block pushes on SEO errors", false).action(async (opts) => {
+var initCommand = new Command("init").description("Initialize indxel in your project").option("--cwd <path>", "Project directory", process.cwd()).option("--force", "Overwrite existing files", false).option("--hook", "Install git pre-push hook to block pushes on SEO errors", false).action(async (opts) => {
   const cwd = opts.cwd;
   const spinner = ora("Detecting project...").start();
   const project = await detectProject(cwd);
-  if (!project.isNextJs) {
-    spinner.fail("Not a Next.js project");
+  if (project.framework === "unknown") {
+    spinner.fail("No supported framework detected");
     console.log(
-      chalk.dim("  indxel currently supports Next.js projects only.")
+      chalk.dim("  Supported: Next.js, Nuxt, Remix, Astro, SvelteKit.")
     );
     console.log(
-      chalk.dim("  Make sure you're in a directory with a next.config file.")
+      chalk.dim("  Make sure you're in a project directory with a config file and package.json.")
     );
     process.exit(1);
   }
-  spinner.succeed(
-    `Detected Next.js ${project.nextVersion ?? ""} (${project.usesAppRouter ? "App Router" : "Pages Router"})`
-  );
+  const label = frameworkLabel(project.framework);
+  const version = project.frameworkVersion ? ` ${project.frameworkVersion}` : "";
+  spinner.succeed(`Detected ${label}${version}`);
   const ext = project.isTypeScript ? "ts" : "js";
   const filesCreated = [];
+  let siteUrl = "https://example.com";
   if (!project.hasSeoConfig || opts.force) {
-    const configPath = join3(cwd, `seo.config.${ext}`);
-    await writeFile2(configPath, seoConfigTemplate(project.isTypeScript), "utf-8");
+    const detection = await detectProjectUrl(cwd, project.framework);
+    if (detection.url && detection.confident) {
+      siteUrl = detection.url;
+      console.log(chalk.green("  \u2713") + ` Detected URL: ${chalk.bold(siteUrl)}` + chalk.dim(` (${detection.source})`));
+    } else if (detection.url) {
+      const answer = await ask(
+        chalk.bold("  Site URL") + chalk.dim(` [${detection.url}] `) + chalk.bold(": ")
+      );
+      siteUrl = answer && answer !== "" ? answer.startsWith("http") ? answer : `https://${answer}` : detection.url;
+    } else {
+      const answer = await ask(chalk.bold("  Site URL: ") + chalk.dim("(e.g., https://mysite.com) "));
+      if (answer && answer !== "") {
+        siteUrl = answer.startsWith("http") ? answer : `https://${answer}`;
+      }
+    }
+    const configPath = join4(cwd, `seo.config.${ext}`);
+    await writeFile2(configPath, seoConfigTemplate(project.isTypeScript, siteUrl), "utf-8");
     filesCreated.push(`seo.config.${ext}`);
-    console.log(chalk.green("  \u2713") + ` Generated seo.config.${ext}`);
+    console.log(chalk.green("  \u2713") + ` Generated seo.config.${ext}` + chalk.dim(` (${siteUrl})`));
   } else {
     console.log(chalk.dim(`  - seo.config.${ext} already exists (skip)`));
   }
-  if (!project.hasSitemap || opts.force) {
-    const sitemapPath = join3(cwd, project.appDir, `sitemap.${ext}`);
-    await writeFile2(sitemapPath, sitemapTemplate(project.isTypeScript), "utf-8");
-    filesCreated.push(`${project.appDir}/sitemap.${ext}`);
-    console.log(chalk.green("  \u2713") + ` Generated ${project.appDir}/sitemap.${ext}`);
-  } else {
-    console.log(chalk.dim(`  - sitemap already exists (skip)`));
-  }
-  if (!project.hasRobots || opts.force) {
-    const robotsPath = join3(cwd, project.appDir, `robots.${ext}`);
-    await writeFile2(robotsPath, robotsTemplate(project.isTypeScript), "utf-8");
-    filesCreated.push(`${project.appDir}/robots.${ext}`);
-    console.log(chalk.green("  \u2713") + ` Generated ${project.appDir}/robots.${ext}`);
+  if (project.framework === "nextjs") {
+    if (!project.hasSitemap || opts.force) {
+      const sitemapPath = join4(cwd, project.appDir, `sitemap.${ext}`);
+      await writeFile2(sitemapPath, sitemapTemplate(project.isTypeScript, siteUrl), "utf-8");
+      filesCreated.push(`${project.appDir}/sitemap.${ext}`);
+      console.log(chalk.green("  \u2713") + ` Generated ${project.appDir}/sitemap.${ext}`);
+    } else {
+      console.log(chalk.dim(`  - sitemap already exists (skip)`));
+    }
+    if (!project.hasRobots || opts.force) {
+      const robotsPath = join4(cwd, project.appDir, `robots.${ext}`);
+      await writeFile2(robotsPath, robotsTemplate(project.isTypeScript, siteUrl), "utf-8");
+      filesCreated.push(`${project.appDir}/robots.${ext}`);
+      console.log(chalk.green("  \u2713") + ` Generated ${project.appDir}/robots.${ext}`);
+    } else {
+      console.log(chalk.dim(`  - robots already exists (skip)`));
+    }
   } else {
-    console.log(chalk.dim(`  - robots already exists (skip)`));
+    if (!project.hasSitemap) {
+      console.log(chalk.yellow("  \u26A0") + " No sitemap detected \u2014 add a public/sitemap.xml or generate one with your framework");
+    }
+    if (!project.hasRobots) {
+      console.log(chalk.yellow("  \u26A0") + " No robots.txt detected \u2014 add a public/robots.txt");
+    }
   }
-  const gitDir = join3(cwd, ".git");
-  const hasGit = existsSync3(gitDir);
+  const gitDir = join4(cwd, ".git");
+  const hasGit = existsSync4(gitDir);
   if (opts.hook || opts.force) {
     if (!hasGit) {
       console.log(chalk.yellow("  \u26A0") + " No .git directory found \u2014 skip hook install");
     } else {
-      const hooksDir = join3(gitDir, "hooks");
-      const hookPath = join3(hooksDir, "pre-push");
-      if (existsSync3(hookPath) && !opts.force) {
-        const existing = await readFile3(hookPath, "utf-8");
+      const hooksDir = join4(gitDir, "hooks");
+      const hookPath = join4(hooksDir, "pre-push");
+      if (existsSync4(hookPath) && !opts.force) {
+        const existing = await readFile4(hookPath, "utf-8");
         if (existing.includes("indxel")) {
           console.log(chalk.dim("  - pre-push hook already installed (skip)"));
         } else {
@@ -354,28 +682,37 @@ var initCommand = new Command("init").description("Initialize indxel in your Nex
   } else if (hasGit) {
     console.log(chalk.dim("  - Use --hook to install git pre-push guard"));
   }
+  const gitignorePath = join4(cwd, ".gitignore");
+  if (existsSync4(gitignorePath)) {
+    const gitignoreContent = await readFile4(gitignorePath, "utf-8");
+    if (!gitignoreContent.includes(".indxel")) {
+      await writeFile2(gitignorePath, gitignoreContent.trimEnd() + "\n\n# Indxel local config (contains API key)\n.indxel/\n", "utf-8");
+      console.log(chalk.green("  \u2713") + " Added .indxel/ to .gitignore");
+    }
+  }
+  const staticDirName = project.framework === "sveltekit" ? "static" : "public";
   const existingKey = await loadIndexNowKey(cwd);
   if (!existingKey || opts.force) {
     const key = generateIndexNowKey();
-    const publicDir = join3(cwd, "public");
-    if (!existsSync3(publicDir)) {
+    const publicDir = join4(cwd, staticDirName);
+    if (!existsSync4(publicDir)) {
       await mkdir2(publicDir, { recursive: true });
     }
-    await writeFile2(join3(publicDir, `${key}.txt`), key, "utf-8");
+    await writeFile2(join4(publicDir, `${key}.txt`), key, "utf-8");
     await saveIndexNowKey(cwd, key);
-    filesCreated.push(`public/${key}.txt`);
+    filesCreated.push(`${staticDirName}/${key}.txt`);
     console.log(chalk.green("  \u2713") + " IndexNow ready \u2014 Bing, Yandex & Naver will pick up your pages on deploy");
   } else {
-    const keyFile = join3(cwd, "public", `${existingKey}.txt`);
-    if (existsSync3(keyFile)) {
+    const keyFile = join4(cwd, staticDirName, `${existingKey}.txt`);
+    if (existsSync4(keyFile)) {
       console.log(chalk.dim("  - IndexNow already set up (skip)"));
     } else {
-      const publicDir = join3(cwd, "public");
-      if (!existsSync3(publicDir)) {
+      const publicDir = join4(cwd, staticDirName);
+      if (!existsSync4(publicDir)) {
         await mkdir2(publicDir, { recursive: true });
       }
       await writeFile2(keyFile, existingKey, "utf-8");
-      filesCreated.push(`public/${existingKey}.txt`);
+      filesCreated.push(`${staticDirName}/${existingKey}.txt`);
       console.log(chalk.green("  \u2713") + " IndexNow key file restored");
     }
   }
@@ -390,8 +727,8 @@ var initCommand = new Command("init").description("Initialize indxel in your Nex
   }
   console.log("");
   console.log(chalk.dim("  Next steps:"));
-  console.log(chalk.dim(`    1. Edit seo.config.${ext} with your site details`));
-  console.log(chalk.dim("    2. Run ") + chalk.bold("npx indxel check") + chalk.dim(" to audit your pages"));
+  console.log(chalk.dim("    1. Run ") + chalk.bold("npx indxel check") + chalk.dim(" to audit your pages"));
+  console.log(chalk.dim("    2. Run ") + chalk.bold("npx indxel crawl") + chalk.dim(" to crawl your live site"));
   if (!opts.hook && hasGit) {
     console.log(chalk.dim("    3. Run ") + chalk.bold("npx indxel init --hook") + chalk.dim(" to guard git pushes"));
   }
@@ -408,23 +745,23 @@ import ora2 from "ora";
 import { validateMetadata } from "indxel";
 
 // src/scanner.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join4, dirname, sep } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join5, dirname, sep } from "path";
 import { glob } from "glob";
 async function scanPages(projectRoot, appDir) {
-  const appDirFull = join4(projectRoot, appDir);
+  const appDirFull = join5(projectRoot, appDir);
   const pageFiles = await glob("**/page.{tsx,ts,jsx,js}", {
     cwd: appDirFull,
     ignore: ["**/node_modules/**", "**/_*/**"]
   });
   const pages = [];
   for (const file of pageFiles) {
-    const fullPath = join4(appDirFull, file);
-    const content = await readFile4(fullPath, "utf-8");
+    const fullPath = join5(appDirFull, file);
+    const content = await readFile5(fullPath, "utf-8");
     const route = filePathToRoute(file);
     const isClient = isClientComponent(content);
     const page = {
-      filePath: join4(appDir, file),
+      filePath: join5(appDir, file),
       route,
       hasMetadata: false,
       hasDynamicMetadata: false,
@@ -444,175 +781,817 @@ async function scanPages(projectRoot, appDir) {
     }
     pages.push(page);
   }
-  const layoutFiles = await glob("**/layout.{tsx,ts,jsx,js}", {
+  const layoutFiles = await glob("**/layout.{tsx,ts,jsx,js}", {
+    cwd: appDirFull,
+    ignore: ["**/node_modules/**", "**/_*/**"]
+  });
+  const sortedLayouts = layoutFiles.sort((a, b) => {
+    const depthA = a.split(sep).length;
+    const depthB = b.split(sep).length;
+    return depthB - depthA;
+  });
+  for (const file of sortedLayouts) {
+    const fullPath = join5(appDirFull, file);
+    const content = await readFile5(fullPath, "utf-8");
+    const route = filePathToRoute(file).replace(/\/layout$/, "") || "/";
+    const hasMetadataExport = hasExport(content, "metadata") || hasExport(content, "generateMetadata");
+    if (hasMetadataExport) {
+      const layoutMeta = extractStaticMetadata(content);
+      const templateMatch = content.match(/template\s*:\s*["'`]([^"'`]+)["'`]/);
+      const titleTemplate = templateMatch?.[1] ?? null;
+      for (const page of pages) {
+        if (page.route.startsWith(route) || route === "/") {
+          if (page.extractedMetadata.title && titleTemplate && !page.titleIsAbsolute) {
+            page.extractedMetadata.title = titleTemplate.replace("%s", page.extractedMetadata.title);
+            page.titleIsAbsolute = true;
+          }
+          mergeMetadata(page.extractedMetadata, layoutMeta);
+          if (!page.hasMetadata) {
+            page.hasMetadata = true;
+          }
+        }
+      }
+    }
+  }
+  return pages.sort((a, b) => a.route.localeCompare(b.route));
+}
+function filePathToRoute(filePath) {
+  const dir = dirname(filePath);
+  if (dir === ".") return "/";
+  const route = "/" + dir.split(sep).join("/");
+  return route.replace(/\/\([^)]+\)/g, "") || "/";
+}
+function isClientComponent(source) {
+  return /^[\s]*(['"])use client\1/.test(source);
+}
+function hasExport(source, name) {
+  const patterns = [
+    new RegExp(`export\\s+(const|let|var)\\s+${name}\\b`),
+    new RegExp(`export\\s+(async\\s+)?function\\s+${name}\\b`),
+    new RegExp(`export\\s+\\{[^}]*\\b${name}\\b[^}]*\\}`)
+  ];
+  return patterns.some((p) => p.test(source));
+}
+function findMetadataBlock(source) {
+  const match = source.match(/export\s+(const|let|var)\s+metadata[\s:]/);
+  if (!match || match.index === void 0) return null;
+  const start = source.indexOf("{", match.index);
+  if (start === -1) return null;
+  let depth = 0;
+  for (let i = start; i < source.length; i++) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) return source.substring(start, i + 1);
+    }
+  }
+  return null;
+}
+function isMetadataFromWrapper(source) {
+  return /export\s+(const|let|var)\s+metadata\s*=\s*[a-zA-Z_$]\w*\s*\(/.test(source);
+}
+function extractStaticMetadata(source) {
+  const meta = createEmptyMetadata();
+  const usesWrapper = isMetadataFromWrapper(source);
+  const metaBlock = findMetadataBlock(source) ?? source;
+  const absoluteMatch = metaBlock.match(
+    /absolute\s*:\s*(["'`])(.*?)\1/s
+  );
+  if (absoluteMatch) {
+    meta.title = absoluteMatch[2];
+  } else {
+    const defaultMatch = metaBlock.match(
+      /default\s*:\s*(["'`])(.*?)\1/s
+    );
+    if (defaultMatch) {
+      meta.title = defaultMatch[2];
+    } else {
+      const titleMatch = metaBlock.match(
+        /(?:^|[,{\n])\s*title\s*:\s*(["'`])(.*?)\1/s
+      );
+      if (titleMatch) {
+        meta.title = titleMatch[2];
+      }
+    }
+  }
+  const descMatch = metaBlock.match(
+    /(?:^|[,{\n])\s*description\s*:\s*\n?\s*(["'`])(.*?)\1/s
+  );
+  if (descMatch) {
+    meta.description = descMatch[2];
+  }
+  if (/openGraph\s*:\s*\{/.test(metaBlock)) {
+    const ogTitleMatch = metaBlock.match(
+      /openGraph\s*:\s*\{[^}]*title\s*:\s*["'`]([^"'`]+)["'`]/s
+    );
+    meta.ogTitle = ogTitleMatch ? ogTitleMatch[1] : "[detected]";
+    const ogDescMatch = metaBlock.match(
+      /openGraph\s*:\s*\{[^}]*description\s*:\s*["'`]([^"'`]+)["'`]/s
+    );
+    meta.ogDescription = ogDescMatch ? ogDescMatch[1] : "[detected]";
+    if (!meta.ogImage) meta.ogImage = "[detected]";
+    if (/images\s*:\s*\[/.test(metaBlock)) {
+      meta.ogImage = "[detected]";
+    }
+  }
+  if (/twitter\s*:\s*\{/.test(metaBlock)) {
+    const cardMatch = metaBlock.match(
+      /card\s*:\s*["'`](summary|summary_large_image)["'`]/
+    );
+    meta.twitterCard = cardMatch ? cardMatch[1] : "[detected]";
+  }
+  if (/robots\s*:\s*\{/.test(metaBlock) || /robots\s*:\s*["'`]/.test(metaBlock)) {
+    const robotsMatch = metaBlock.match(
+      /robots\s*:\s*["'`]([^"'`]+)["'`]/
+    );
+    if (robotsMatch) meta.robots = robotsMatch[1];
+  }
+  if (/alternates\s*:\s*\{/.test(metaBlock)) {
+    const canonicalMatch = metaBlock.match(
+      /canonical\s*:\s*["'`]([^"'`]+)["'`]/
+    );
+    if (canonicalMatch) {
+      meta.canonical = canonicalMatch[1];
+    } else if (/canonical\s*:/.test(metaBlock)) {
+      meta.canonical = "[detected]";
+    }
+    if (/languages\s*:\s*\{/.test(metaBlock)) {
+      const langs = {};
+      const langMatches = metaBlock.matchAll(
+        /["'`](\w{2}(?:-\w{2})?)["'`]\s*:\s*["'`]([^"'`]+)["'`]/g
+      );
+      for (const m of langMatches) {
+        if (m[1] && m[2] && m[2].startsWith("http")) {
+          langs[m[1]] = m[2];
+        }
+      }
+      if (Object.keys(langs).length > 0) {
+        meta.alternates = langs;
+      }
+    }
+  }
+  if (!meta.title && /(?:^|[,{\n])\s*title\s*:\s*(?:\{|[a-zA-Z_$])/.test(metaBlock)) {
+    meta.title = "[detected]";
+  }
+  if (!meta.description && /(?:^|[,{\n])\s*description\s*:\s*[a-zA-Z_$]/.test(metaBlock)) {
+    meta.description = "[detected]";
+  }
+  if (usesWrapper && (meta.title || meta.description)) {
+    if (!meta.ogTitle) meta.ogTitle = "[detected]";
+    if (!meta.ogDescription) meta.ogDescription = "[detected]";
+    if (!meta.ogImage) meta.ogImage = "[detected]";
+    if (!meta.twitterCard) meta.twitterCard = "[detected]";
+    if (!meta.canonical) meta.canonical = "[detected]";
+    if (!meta.robots) meta.robots = "[detected]";
+  }
+  if (/application\/ld\+json/.test(source) || /generateLD/.test(source) || /JsonLD/.test(source)) {
+    meta.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
+  }
+  if (/viewport\s*[:=]/.test(source)) {
+    meta.viewport = "detected";
+  }
+  if (/icons\s*:\s*\{/.test(metaBlock) || /favicon/.test(metaBlock)) {
+    meta.favicon = "detected";
+  }
+  return meta;
+}
+function createEmptyMetadata() {
+  return {
+    title: null,
+    description: null,
+    canonical: null,
+    ogTitle: null,
+    ogDescription: null,
+    ogImage: null,
+    ogType: null,
+    twitterCard: null,
+    twitterTitle: null,
+    twitterDescription: null,
+    robots: null,
+    alternates: null,
+    structuredData: null,
+    viewport: null,
+    favicon: null
+  };
+}
+function mergeMetadata(target, source) {
+  for (const key of Object.keys(source)) {
+    if (target[key] === null || target[key] === void 0) {
+      target[key] = source[key];
+    }
+  }
+}
+
+// src/scanner-nuxt.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join6, sep as sep2 } from "path";
+import { glob as glob2 } from "glob";
+async function scanNuxtPages(projectRoot, appDir) {
+  const appDirFull = join6(projectRoot, appDir);
+  const pageFiles = await glob2("**/*.vue", {
+    cwd: appDirFull,
+    ignore: ["**/node_modules/**", "**/components/**", "**/_*/**"]
+  });
+  const pages = [];
+  for (const file of pageFiles) {
+    const fullPath = join6(appDirFull, file);
+    const content = await readFile6(fullPath, "utf-8");
+    const route = vueFilePathToRoute(file);
+    const page = {
+      filePath: join6(appDir, file),
+      route,
+      hasMetadata: false,
+      hasDynamicMetadata: false,
+      isClientComponent: false,
+      titleIsAbsolute: false,
+      extractedMetadata: createEmptyMetadata2()
+    };
+    const hasUseSeoMeta = /useSeoMeta\s*\(/.test(content);
+    const hasUseHead = /useHead\s*\(/.test(content);
+    const hasDefinePageMeta = /definePageMeta\s*\(/.test(content);
+    page.hasMetadata = hasUseSeoMeta || hasUseHead || hasDefinePageMeta;
+    if (page.hasMetadata) {
+      const hasComputed = /computed\s*\(/.test(content) || /useAsyncData/.test(content) || /useFetch/.test(content);
+      page.hasDynamicMetadata = hasComputed;
+    }
+    if (hasUseSeoMeta) {
+      page.extractedMetadata = extractNuxtSeoMeta(content);
+    } else if (hasUseHead) {
+      page.extractedMetadata = extractNuxtUseHead(content);
+    }
+    pages.push(page);
+  }
+  const layoutSources = [];
+  try {
+    const appVueContent = await readFile6(join6(projectRoot, "app.vue"), "utf-8");
+    layoutSources.push({ content: appVueContent, scope: "global" });
+  } catch {
+  }
+  const layoutDir = join6(projectRoot, "layouts");
+  try {
+    const layoutFiles = await glob2("**/*.vue", {
+      cwd: layoutDir,
+      ignore: ["**/node_modules/**"]
+    });
+    for (const file of layoutFiles) {
+      try {
+        const content = await readFile6(join6(layoutDir, file), "utf-8");
+        layoutSources.push({ content, scope: "global" });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  for (const layout of layoutSources) {
+    const hasUseSeoMeta = /useSeoMeta\s*\(/.test(layout.content);
+    const hasUseHead = /useHead\s*\(/.test(layout.content);
+    if (!hasUseSeoMeta && !hasUseHead) continue;
+    const layoutMeta = hasUseSeoMeta ? extractNuxtSeoMeta(layout.content) : extractNuxtUseHead(layout.content);
+    const templateMatch = layout.content.match(/titleTemplate\s*:\s*["'`]([^"'`]+)["'`]/);
+    const titleTemplate = templateMatch?.[1] ?? null;
+    for (const page of pages) {
+      if (page.extractedMetadata.title && titleTemplate && !page.titleIsAbsolute && page.extractedMetadata.title !== "[detected]") {
+        page.extractedMetadata.title = titleTemplate.replace("%s", page.extractedMetadata.title);
+        page.titleIsAbsolute = true;
+      }
+      mergeMetadata2(page.extractedMetadata, layoutMeta);
+      if (!page.hasMetadata) page.hasMetadata = true;
+    }
+  }
+  return pages.sort((a, b) => a.route.localeCompare(b.route));
+}
+function vueFilePathToRoute(filePath) {
+  let route = filePath.replace(/\.vue$/, "");
+  route = route.replace(/\/index$/, "").replace(/^index$/, "");
+  route = "/" + route.split(sep2).join("/");
+  route = route.replace(/\/\([^)]+\)/g, "") || "/";
+  return route;
+}
+function extractNuxtSeoMeta(source) {
+  const meta = createEmptyMetadata2();
+  const block = findCallBlock(source, "useSeoMeta");
+  if (!block) return meta;
+  const titleMatch = block.match(/(?<![a-zA-Z])title\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (titleMatch) meta.title = titleMatch[1];
+  const descMatch = block.match(/(?<![a-zA-Z])description\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (descMatch) meta.description = descMatch[1];
+  const ogTitleMatch = block.match(/ogTitle\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogTitleMatch) meta.ogTitle = ogTitleMatch[1];
+  const ogDescMatch = block.match(/ogDescription\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogDescMatch) meta.ogDescription = ogDescMatch[1];
+  const ogImageMatch = block.match(/ogImage\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogImageMatch) meta.ogImage = ogImageMatch[1];
+  const twitterCardMatch = block.match(/twitterCard\s*:\s*["'`](summary|summary_large_image)["'`]/);
+  if (twitterCardMatch) meta.twitterCard = twitterCardMatch[1];
+  const robotsMatch = block.match(/(?<![a-zA-Z])robots\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (robotsMatch) meta.robots = robotsMatch[1];
+  if (!meta.title && /(?<![a-zA-Z])title\s*:\s*[a-zA-Z_$]/.test(block)) meta.title = "[detected]";
+  if (!meta.description && /(?<![a-zA-Z])description\s*:\s*[a-zA-Z_$]/.test(block)) meta.description = "[detected]";
+  if (!meta.ogTitle && /ogTitle\s*:\s*[a-zA-Z_$]/.test(block)) meta.ogTitle = "[detected]";
+  if (!meta.ogDescription && /ogDescription\s*:\s*[a-zA-Z_$]/.test(block)) meta.ogDescription = "[detected]";
+  if (!meta.ogImage && /ogImage\s*:\s*[a-zA-Z_$]/.test(block)) meta.ogImage = "[detected]";
+  return meta;
+}
+function extractNuxtUseHead(source) {
+  const meta = createEmptyMetadata2();
+  const block = findCallBlock(source, "useHead");
+  if (!block) return meta;
+  const titleMatch = block.match(/title\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (titleMatch) meta.title = titleMatch[1];
+  const descMatch = block.match(/name\s*:\s*["'`]description["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (descMatch) meta.description = descMatch[1];
+  const ogTitleMatch = block.match(/property\s*:\s*["'`]og:title["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogTitleMatch) meta.ogTitle = ogTitleMatch[1];
+  const ogDescMatch = block.match(/property\s*:\s*["'`]og:description["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogDescMatch) meta.ogDescription = ogDescMatch[1];
+  const ogImageMatch = block.match(/property\s*:\s*["'`]og:image["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogImageMatch) meta.ogImage = ogImageMatch[1];
+  if (!meta.title && /title\s*:\s*[a-zA-Z_$]/.test(block)) meta.title = "[detected]";
+  if (/application\/ld\+json/.test(source)) {
+    meta.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
+  }
+  return meta;
+}
+function findCallBlock(source, funcName) {
+  const regex = new RegExp(`${funcName}\\s*\\(`);
+  const match = source.match(regex);
+  if (!match || match.index === void 0) return null;
+  const start = source.indexOf("(", match.index);
+  if (start === -1) return null;
+  let depth = 0;
+  for (let i = start; i < source.length; i++) {
+    if (source[i] === "(") depth++;
+    else if (source[i] === ")") {
+      depth--;
+      if (depth === 0) return source.substring(start, i + 1);
+    }
+  }
+  return null;
+}
+function createEmptyMetadata2() {
+  return {
+    title: null,
+    description: null,
+    canonical: null,
+    ogTitle: null,
+    ogDescription: null,
+    ogImage: null,
+    ogType: null,
+    twitterCard: null,
+    twitterTitle: null,
+    twitterDescription: null,
+    robots: null,
+    alternates: null,
+    structuredData: null,
+    viewport: null,
+    favicon: null
+  };
+}
+function mergeMetadata2(target, source) {
+  for (const key of Object.keys(source)) {
+    if (target[key] === null || target[key] === void 0) {
+      target[key] = source[key];
+    }
+  }
+}
+
+// src/scanner-remix.ts
+import { readFile as readFile7 } from "fs/promises";
+import { join as join7, sep as sep3 } from "path";
+import { glob as glob3 } from "glob";
+async function scanRemixPages(projectRoot, appDir) {
+  const appDirFull = join7(projectRoot, appDir);
+  const routeFiles = await glob3("**/*.{tsx,ts,jsx,js}", {
+    cwd: appDirFull,
+    ignore: ["**/node_modules/**", "**/__*/**", "**/*.server.*", "**/*.client.*"]
+  });
+  const pages = [];
+  for (const file of routeFiles) {
+    const fullPath = join7(appDirFull, file);
+    const content = await readFile7(fullPath, "utf-8");
+    const route = remixFilePathToRoute(file);
+    const page = {
+      filePath: join7(appDir, file),
+      route,
+      hasMetadata: false,
+      hasDynamicMetadata: false,
+      isClientComponent: false,
+      titleIsAbsolute: false,
+      extractedMetadata: createEmptyMetadata3()
+    };
+    const hasMetaExport = hasExport2(content, "meta");
+    page.hasMetadata = hasMetaExport;
+    if (hasMetaExport) {
+      const metaBody = extractMetaBody(content);
+      if (metaBody) {
+        const usesData = /\bdata\./.test(metaBody) || /\bdata\[/.test(metaBody);
+        const usesMatches = /\bmatches\b/.test(metaBody);
+        const usesParams = /\bparams\./.test(metaBody);
+        page.hasDynamicMetadata = usesData || usesMatches || usesParams;
+      }
+    }
+    if (hasMetaExport) {
+      page.extractedMetadata = extractRemixMeta(content);
+    }
+    if (/application\/ld\+json/.test(content)) {
+      page.extractedMetadata.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
+    }
+    pages.push(page);
+  }
+  for (const rootFile of ["root.tsx", "root.jsx", "root.ts", "root.js"]) {
+    const rootPath = join7(projectRoot, "app", rootFile);
+    try {
+      const rootContent = await readFile7(rootPath, "utf-8");
+      if (hasExport2(rootContent, "meta")) {
+        const rootMeta = extractRemixMeta(rootContent);
+        for (const page of pages) {
+          mergeMetadata3(page.extractedMetadata, rootMeta);
+          if (!page.hasMetadata) page.hasMetadata = true;
+        }
+      }
+    } catch {
+    }
+  }
+  return pages.sort((a, b) => a.route.localeCompare(b.route));
+}
+function remixFilePathToRoute(filePath) {
+  let route = filePath.replace(/\.(tsx|ts|jsx|js)$/, "").replace(/\/index$/, "").replace(/^index$/, "");
+  route = route.replace(/\._index$/, "");
+  route = route.replace(/\$/g, "[").replace(/\./g, "/");
+  route = route.replace(/\[([^/]+)/g, (_, name) => `[${name}]`);
+  route = "/" + route.split(sep3).join("/");
+  route = route.replace(/\/_[^/]+/g, "");
+  return route || "/";
+}
+function extractRemixMeta(source) {
+  const meta = createEmptyMetadata3();
+  const metaMatch = source.match(/export\s+(?:const|function)\s+meta\s*=?\s*(?:\([^)]*\)\s*(?:=>)?\s*)?[\[({]/);
+  if (!metaMatch || metaMatch.index === void 0) return meta;
+  const startIdx = metaMatch.index;
+  const block = source.substring(startIdx, Math.min(startIdx + 2e3, source.length));
+  const titleMatch = block.match(/\{\s*title\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (titleMatch) meta.title = titleMatch[1];
+  const descMatch = block.match(/name\s*:\s*["'`]description["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (descMatch) meta.description = descMatch[1];
+  const ogTitleMatch = block.match(/property\s*:\s*["'`]og:title["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogTitleMatch) meta.ogTitle = ogTitleMatch[1];
+  const ogDescMatch = block.match(/property\s*:\s*["'`]og:description["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogDescMatch) meta.ogDescription = ogDescMatch[1];
+  const ogImageMatch = block.match(/property\s*:\s*["'`]og:image["'`]\s*,\s*content\s*:\s*["'`]([^"'`]+)["'`]/);
+  if (ogImageMatch) meta.ogImage = ogImageMatch[1];
+  if (!meta.title && /title\s*:\s*[a-zA-Z_$]/.test(block)) meta.title = "[detected]";
+  return meta;
+}
+function extractMetaBody(source) {
+  const arrowMatch = source.match(/export\s+(?:const|let|var)\s+meta\s*=\s*\([^)]*\)\s*(?::\s*[^=]*?)?\s*=>\s*/);
+  if (arrowMatch && arrowMatch.index !== void 0) {
+    const bodyStart = arrowMatch.index + arrowMatch[0].length;
+    return source.substring(bodyStart, Math.min(bodyStart + 3e3, source.length));
+  }
+  const funcMatch = source.match(/export\s+function\s+meta\s*\([^)]*\)\s*(?::\s*[^{]*)?\s*\{/);
+  if (funcMatch && funcMatch.index !== void 0) {
+    const bodyStart = funcMatch.index + funcMatch[0].length;
+    return source.substring(bodyStart, Math.min(bodyStart + 3e3, source.length));
+  }
+  return null;
+}
+function hasExport2(source, name) {
+  const patterns = [
+    new RegExp(`export\\s+(const|let|var)\\s+${name}\\b`),
+    new RegExp(`export\\s+(async\\s+)?function\\s+${name}\\b`),
+    new RegExp(`export\\s+\\{[^}]*\\b${name}\\b[^}]*\\}`)
+  ];
+  return patterns.some((p) => p.test(source));
+}
+function createEmptyMetadata3() {
+  return {
+    title: null,
+    description: null,
+    canonical: null,
+    ogTitle: null,
+    ogDescription: null,
+    ogImage: null,
+    ogType: null,
+    twitterCard: null,
+    twitterTitle: null,
+    twitterDescription: null,
+    robots: null,
+    alternates: null,
+    structuredData: null,
+    viewport: null,
+    favicon: null
+  };
+}
+function mergeMetadata3(target, source) {
+  for (const key of Object.keys(source)) {
+    if (target[key] === null || target[key] === void 0) {
+      target[key] = source[key];
+    }
+  }
+}
+
+// src/scanner-astro.ts
+import { readFile as readFile8 } from "fs/promises";
+import { join as join8, sep as sep4 } from "path";
+import { glob as glob4 } from "glob";
+async function scanAstroPages(projectRoot, appDir) {
+  const appDirFull = join8(projectRoot, appDir);
+  const pageFiles = await glob4("**/*.{astro,md,mdx}", {
+    cwd: appDirFull,
+    ignore: ["**/node_modules/**", "**/_*/**", "**/components/**"]
+  });
+  const pages = [];
+  for (const file of pageFiles) {
+    const fullPath = join8(appDirFull, file);
+    const content = await readFile8(fullPath, "utf-8");
+    const route = astroFilePathToRoute(file);
+    const page = {
+      filePath: join8(appDir, file),
+      route,
+      hasMetadata: false,
+      hasDynamicMetadata: false,
+      isClientComponent: false,
+      titleIsAbsolute: false,
+      extractedMetadata: createEmptyMetadata4()
+    };
+    if (file.endsWith(".md") || file.endsWith(".mdx")) {
+      page.extractedMetadata = extractMarkdownMeta(content);
+      page.hasMetadata = page.extractedMetadata.title !== null || page.extractedMetadata.description !== null;
+    } else {
+      page.extractedMetadata = extractAstroMeta(content);
+      page.hasMetadata = hasAstroSeoSetup(content);
+      page.hasDynamicMetadata = /Astro\.props/.test(content) || /getStaticPaths/.test(content);
+    }
+    if (/application\/ld\+json/.test(content)) {
+      page.extractedMetadata.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
+    }
+    pages.push(page);
+  }
+  const layoutFiles = await glob4("**/layouts/**/*.astro", {
+    cwd: join8(projectRoot, "src"),
+    ignore: ["**/node_modules/**"]
+  });
+  const layoutNames = /* @__PURE__ */ new Set();
+  for (const file of layoutFiles) {
+    try {
+      const content = await readFile8(join8(projectRoot, "src", file), "utf-8");
+      if (hasAstroSeoSetup(content) || /Astro\.props/.test(content)) {
+        const name = file.replace(/.*\//, "").replace(/\.astro$/, "");
+        layoutNames.add(name);
+        const layoutMeta = extractAstroMeta(content);
+        const staticLayoutMeta = { ...layoutMeta };
+        if (staticLayoutMeta.title === "[detected]") staticLayoutMeta.title = null;
+        if (staticLayoutMeta.description === "[detected]") staticLayoutMeta.description = null;
+        for (const page of pages) {
+          mergeMetadata4(page.extractedMetadata, staticLayoutMeta);
+        }
+      }
+    } catch {
+    }
+  }
+  if (layoutNames.size > 0) {
+    const layoutPattern = new RegExp(
+      `<(?:${[...layoutNames].join("|")})\\s([^>]*)`,
+      "g"
+    );
+    for (const page of pages) {
+      const fullPath = join8(appDirFull, page.filePath.replace(appDir + "/", ""));
+      try {
+        const content = await readFile8(fullPath, "utf-8");
+        const matches = content.matchAll(layoutPattern);
+        for (const m of matches) {
+          const attrs = m[1];
+          if (!page.extractedMetadata.title) {
+            const titleProp = attrs.match(/title=["']([^"']+)["']/);
+            if (titleProp) page.extractedMetadata.title = titleProp[1];
+            else if (/title=\{/.test(attrs)) page.extractedMetadata.title = "[detected]";
+          }
+          if (!page.extractedMetadata.description) {
+            const descProp = attrs.match(/description=["']([^"']+)["']/);
+            if (descProp) page.extractedMetadata.description = descProp[1];
+            else if (/description=\{/.test(attrs)) page.extractedMetadata.description = "[detected]";
+          }
+          if (page.extractedMetadata.title || page.extractedMetadata.description) {
+            page.hasMetadata = true;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return pages.sort((a, b) => a.route.localeCompare(b.route));
+}
+function astroFilePathToRoute(filePath) {
+  let route = filePath.replace(/\.(astro|md|mdx)$/, "").replace(/\/index$/, "").replace(/^index$/, "");
+  route = "/" + route.split(sep4).join("/");
+  return route || "/";
+}
+function hasAstroSeoSetup(source) {
+  const hasSeoMeta = /<meta\s[^>]*name=["']description["']/.test(source) || /<meta\s[^>]*property=["']og:/.test(source) || /<meta\s[^>]*name=["']robots["']/.test(source) || /<meta\s[^>]*name=["']twitter:/.test(source) || /<meta\s[^>]*content=["'][^"']*["'][^>]*name=["']description["']/.test(source) || /<meta\s[^>]*content=["'][^"']*["'][^>]*property=["']og:/.test(source);
+  return /<title[\s>]/.test(source) || hasSeoMeta || /<SEO[\s/>]/.test(source) || // Common Astro SEO component
+  /<BaseHead[\s/>]/.test(source) || // Common Astro pattern
+  /@astrojs\/seo/.test(source) || /astro-seo/.test(source) || /Astro\.props\.title/.test(source);
+}
+function extractMetaTag(source, attr, name) {
+  const r1 = new RegExp(`<meta\\s[^>]*${attr}=["']${name}["'][^>]*content=["']([^"']+)["']`, "i");
+  const m1 = source.match(r1);
+  if (m1) return m1[1];
+  const r2 = new RegExp(`<meta\\s[^>]*content=["']([^"']+)["'][^>]*${attr}=["']${name}["']`, "i");
+  const m2 = source.match(r2);
+  if (m2) return m2[1];
+  return null;
+}
+function hasMetaTagDynamic(source, attr, name) {
+  const r1 = new RegExp(`<meta\\s[^>]*${attr}=["']${name}["'][^>]*content=\\{`);
+  const r2 = new RegExp(`<meta\\s[^>]*content=\\{[^}]*\\}[^>]*${attr}=["']${name}["']`);
+  return r1.test(source) || r2.test(source);
+}
+function extractAstroMeta(source) {
+  const meta = createEmptyMetadata4();
+  const titleTagMatch = source.match(/<title[^>]*>([^<{]+)<\/title>/);
+  if (titleTagMatch) meta.title = titleTagMatch[1].trim();
+  meta.description = extractMetaTag(source, "name", "description");
+  meta.ogTitle = extractMetaTag(source, "property", "og:title");
+  meta.ogDescription = extractMetaTag(source, "property", "og:description");
+  meta.ogImage = extractMetaTag(source, "property", "og:image");
+  meta.robots = extractMetaTag(source, "name", "robots");
+  const canonicalMatch = source.match(/<link\s[^>]*rel=["']canonical["'][^>]*href=["']([^"']+)["']/) || source.match(/<link\s[^>]*href=["']([^"']+)["'][^>]*rel=["']canonical["']/);
+  if (canonicalMatch) meta.canonical = canonicalMatch[1];
+  if (!meta.title) {
+    const titleContent = source.match(/<title[^>]*>([\s\S]*?)<\/title>/)?.[1] ?? "";
+    if (/\{/.test(titleContent)) meta.title = "[detected]";
+  }
+  if (!meta.description && hasMetaTagDynamic(source, "name", "description")) meta.description = "[detected]";
+  if (!meta.ogTitle && hasMetaTagDynamic(source, "property", "og:title")) meta.ogTitle = "[detected]";
+  if (!meta.ogDescription && hasMetaTagDynamic(source, "property", "og:description")) meta.ogDescription = "[detected]";
+  if (!meta.ogImage && hasMetaTagDynamic(source, "property", "og:image")) meta.ogImage = "[detected]";
+  if (!meta.title) {
+    const seoComponentMatch = source.match(/<(?:SEO|BaseHead|Head)\s[^>]*title=["']([^"']+)["']/);
+    if (seoComponentMatch) meta.title = seoComponentMatch[1];
+  }
+  if (!meta.title) {
+    if (/<(?:SEO|BaseHead|Head)\s[^>]*title=\{/.test(source)) meta.title = "[detected]";
+  }
+  if (!meta.description) {
+    const seoDescMatch = source.match(/<(?:SEO|BaseHead|Head)\s[^>]*description=["']([^"']+)["']/);
+    if (seoDescMatch) meta.description = seoDescMatch[1];
+    else if (/<(?:SEO|BaseHead|Head)\s[^>]*description=\{/.test(source)) meta.description = "[detected]";
+  }
+  if (/application\/ld\+json/.test(source)) {
+    meta.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
+  }
+  return meta;
+}
+function extractMarkdownMeta(source) {
+  const meta = createEmptyMetadata4();
+  const fmMatch = source.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!fmMatch) return meta;
+  const fm = fmMatch[1];
+  const titleMatch = fm.match(/^title\s*:\s*["']?(.+?)["']?\s*$/m);
+  if (titleMatch) meta.title = titleMatch[1];
+  const descMatch = fm.match(/^description\s*:\s*["']?(.+?)["']?\s*$/m);
+  if (descMatch) meta.description = descMatch[1];
+  const ogImageMatch = fm.match(/^(?:ogImage|image|og_image)\s*:\s*["']?(.+?)["']?\s*$/m);
+  if (ogImageMatch) meta.ogImage = ogImageMatch[1];
+  return meta;
+}
+function createEmptyMetadata4() {
+  return {
+    title: null,
+    description: null,
+    canonical: null,
+    ogTitle: null,
+    ogDescription: null,
+    ogImage: null,
+    ogType: null,
+    twitterCard: null,
+    twitterTitle: null,
+    twitterDescription: null,
+    robots: null,
+    alternates: null,
+    structuredData: null,
+    viewport: null,
+    favicon: null
+  };
+}
+function mergeMetadata4(target, source) {
+  for (const key of Object.keys(source)) {
+    if (target[key] === null || target[key] === void 0) {
+      target[key] = source[key];
+    }
+  }
+}
+
+// src/scanner-sveltekit.ts
+import { readFile as readFile9 } from "fs/promises";
+import { join as join9, dirname as dirname5, sep as sep5 } from "path";
+import { glob as glob5 } from "glob";
+async function scanSvelteKitPages(projectRoot, appDir) {
+  const appDirFull = join9(projectRoot, appDir);
+  const pageFiles = await glob5("**/+page.svelte", {
+    cwd: appDirFull,
+    ignore: ["**/node_modules/**"]
+  });
+  const pages = [];
+  for (const file of pageFiles) {
+    const fullPath = join9(appDirFull, file);
+    const content = await readFile9(fullPath, "utf-8");
+    const route = svelteKitFilePathToRoute(file);
+    const page = {
+      filePath: join9(appDir, file),
+      route,
+      hasMetadata: false,
+      hasDynamicMetadata: false,
+      isClientComponent: false,
+      titleIsAbsolute: false,
+      extractedMetadata: createEmptyMetadata5()
+    };
+    const hasSvelteHead = /<svelte:head[\s>]/.test(content);
+    page.hasMetadata = hasSvelteHead;
+    if (hasSvelteHead) {
+      page.extractedMetadata = extractSvelteHeadMeta(content);
+      const headBlock = content.match(/<svelte:head[\s>]([\s\S]*?)<\/svelte:head>/)?.[1] ?? "";
+      const headUsesData = /\bdata\./.test(headBlock) || /\$page/.test(headBlock) || /\{#each/.test(headBlock);
+      page.hasDynamicMetadata = headUsesData;
+    }
+    if (/application\/ld\+json/.test(content)) {
+      page.extractedMetadata.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
+    }
+    pages.push(page);
+  }
+  const layoutFiles = await glob5("**/+layout.svelte", {
     cwd: appDirFull,
-    ignore: ["**/node_modules/**", "**/_*/**"]
+    ignore: ["**/node_modules/**"]
   });
   const sortedLayouts = layoutFiles.sort((a, b) => {
-    const depthA = a.split(sep).length;
-    const depthB = b.split(sep).length;
+    const depthA = a.split(sep5).length;
+    const depthB = b.split(sep5).length;
     return depthB - depthA;
   });
   for (const file of sortedLayouts) {
-    const fullPath = join4(appDirFull, file);
-    const content = await readFile4(fullPath, "utf-8");
-    const route = filePathToRoute(file).replace(/\/layout$/, "") || "/";
-    const hasMetadataExport = hasExport(content, "metadata") || hasExport(content, "generateMetadata");
-    if (hasMetadataExport) {
-      const layoutMeta = extractStaticMetadata(content);
-      const templateMatch = content.match(/template\s*:\s*["'`]([^"'`]+)["'`]/);
-      const titleTemplate = templateMatch?.[1] ?? null;
+    try {
+      const content = await readFile9(join9(appDirFull, file), "utf-8");
+      if (!/<svelte:head[\s>]/.test(content)) continue;
+      const layoutMeta = extractSvelteHeadMeta(content);
+      const layoutRoute = svelteKitFilePathToRoute(file).replace(/\/\+layout$/, "") || "/";
       for (const page of pages) {
-        if (page.route.startsWith(route) || route === "/") {
-          if (page.extractedMetadata.title && titleTemplate && !page.titleIsAbsolute) {
-            page.extractedMetadata.title = titleTemplate.replace("%s", page.extractedMetadata.title);
-            page.titleIsAbsolute = true;
-          }
-          mergeMetadata(page.extractedMetadata, layoutMeta);
-          if (!page.hasMetadata) {
-            page.hasMetadata = true;
-          }
+        if (page.route.startsWith(layoutRoute) || layoutRoute === "/") {
+          mergeMetadata5(page.extractedMetadata, layoutMeta);
+          if (!page.hasMetadata) page.hasMetadata = true;
         }
       }
+    } catch {
     }
   }
   return pages.sort((a, b) => a.route.localeCompare(b.route));
 }
-function filePathToRoute(filePath) {
-  const dir = dirname(filePath);
+function svelteKitFilePathToRoute(filePath) {
+  const dir = dirname5(filePath);
   if (dir === ".") return "/";
-  const route = "/" + dir.split(sep).join("/");
-  return route.replace(/\/\([^)]+\)/g, "") || "/";
-}
-function isClientComponent(source) {
-  return /^[\s]*(['"])use client\1/.test(source);
-}
-function hasExport(source, name) {
-  const patterns = [
-    new RegExp(`export\\s+(const|let|var)\\s+${name}\\b`),
-    new RegExp(`export\\s+(async\\s+)?function\\s+${name}\\b`),
-    new RegExp(`export\\s+\\{[^}]*\\b${name}\\b[^}]*\\}`)
-  ];
-  return patterns.some((p) => p.test(source));
-}
-function findMetadataBlock(source) {
-  const match = source.match(/export\s+(const|let|var)\s+metadata[\s:]/);
-  if (!match || match.index === void 0) return null;
-  const start = source.indexOf("{", match.index);
-  if (start === -1) return null;
-  let depth = 0;
-  for (let i = start; i < source.length; i++) {
-    if (source[i] === "{") depth++;
-    else if (source[i] === "}") {
-      depth--;
-      if (depth === 0) return source.substring(start, i + 1);
-    }
-  }
-  return null;
+  let route = "/" + dir.split(sep5).join("/");
+  route = route.replace(/\/\([^)]+\)/g, "") || "/";
+  return route;
 }
-function extractStaticMetadata(source) {
-  const meta = createEmptyMetadata();
-  const metaBlock = findMetadataBlock(source) ?? source;
-  const absoluteMatch = metaBlock.match(
-    /absolute\s*:\s*["'`]([^"'`]+)["'`]/
-  );
-  if (absoluteMatch) {
-    meta.title = absoluteMatch[1];
-  } else {
-    const defaultMatch = metaBlock.match(
-      /default\s*:\s*["'`]([^"'`]+)["'`]/
-    );
-    if (defaultMatch) {
-      meta.title = defaultMatch[1];
-    } else {
-      const titleMatch = metaBlock.match(
-        /(?:^|[,{\n])\s*title\s*:\s*["'`]([^"'`]+)["'`]/
-      );
-      if (titleMatch) {
-        meta.title = titleMatch[1];
-      }
-    }
-  }
-  const descMatch = metaBlock.match(
-    /(?:^|[,{\n])\s*description\s*:\s*\n?\s*["'`]([^"'`]+)["'`]/
-  );
-  if (descMatch) {
-    meta.description = descMatch[1];
-  }
-  if (/openGraph\s*:\s*\{/.test(metaBlock)) {
-    const ogTitleMatch = metaBlock.match(
-      /openGraph\s*:\s*\{[^}]*title\s*:\s*["'`]([^"'`]+)["'`]/s
-    );
-    if (ogTitleMatch) meta.ogTitle = ogTitleMatch[1];
-    const ogDescMatch = metaBlock.match(
-      /openGraph\s*:\s*\{[^}]*description\s*:\s*["'`]([^"'`]+)["'`]/s
-    );
-    if (ogDescMatch) meta.ogDescription = ogDescMatch[1];
-    if (/images\s*:\s*\[/.test(metaBlock)) {
-      meta.ogImage = "[detected]";
-    }
-  }
-  if (/twitter\s*:\s*\{/.test(metaBlock)) {
-    const cardMatch = metaBlock.match(
-      /card\s*:\s*["'`](summary|summary_large_image)["'`]/
-    );
-    if (cardMatch) meta.twitterCard = cardMatch[1];
-  }
-  if (/robots\s*:\s*\{/.test(metaBlock) || /robots\s*:\s*["'`]/.test(metaBlock)) {
-    const robotsMatch = metaBlock.match(
-      /robots\s*:\s*["'`]([^"'`]+)["'`]/
-    );
-    if (robotsMatch) meta.robots = robotsMatch[1];
-  }
-  if (/alternates\s*:\s*\{/.test(metaBlock)) {
-    const canonicalMatch = metaBlock.match(
-      /canonical\s*:\s*["'`]([^"'`]+)["'`]/
-    );
-    if (canonicalMatch) meta.canonical = canonicalMatch[1];
-    if (/languages\s*:\s*\{/.test(metaBlock)) {
-      const langs = {};
-      const langMatches = metaBlock.matchAll(
-        /["'`](\w{2}(?:-\w{2})?)["'`]\s*:\s*["'`]([^"'`]+)["'`]/g
-      );
-      for (const m of langMatches) {
-        if (m[1] && m[2] && m[2].startsWith("http")) {
-          langs[m[1]] = m[2];
-        }
-      }
-      if (Object.keys(langs).length > 0) {
-        meta.alternates = langs;
-      }
-    }
-  }
-  if (!meta.title && /(?:^|[,{\n])\s*title\s*:\s*(?:\{|[a-zA-Z_$])/.test(metaBlock)) {
-    meta.title = "[detected]";
-  }
-  if (!meta.description && /(?:^|[,{\n])\s*description\s*:\s*[a-zA-Z_$]/.test(metaBlock)) {
-    meta.description = "[detected]";
-  }
-  if (/openGraph\s*:\s*\{/.test(metaBlock)) {
-    if (!meta.ogTitle) meta.ogTitle = "[detected]";
-    if (!meta.ogDescription) meta.ogDescription = "[detected]";
-    if (!meta.ogImage) meta.ogImage = "[detected]";
-  }
-  if (/twitter\s*:\s*\{/.test(metaBlock)) {
-    if (!meta.twitterCard) meta.twitterCard = "[detected]";
-  }
-  if (/alternates\s*:\s*\{/.test(metaBlock) && !meta.canonical) {
-    if (/canonical\s*:/.test(metaBlock)) meta.canonical = "[detected]";
-  }
-  if (/application\/ld\+json/.test(source) || /generateLD/.test(source) || /JsonLD/.test(source)) {
+function extractSvelteHeadMeta(source) {
+  const meta = createEmptyMetadata5();
+  const headMatch = source.match(/<svelte:head[\s>]([\s\S]*?)<\/svelte:head>/);
+  if (!headMatch) return meta;
+  const head = headMatch[1];
+  const titleMatch = head.match(/<title[^>]*>([^<{]+)<\/title>/);
+  if (titleMatch) meta.title = titleMatch[1].trim();
+  if (!meta.title && /<title[^>]*>\{/.test(head)) meta.title = "[detected]";
+  meta.description = extractMetaTag2(head, "name", "description");
+  meta.ogTitle = extractMetaTag2(head, "property", "og:title");
+  meta.ogDescription = extractMetaTag2(head, "property", "og:description");
+  meta.ogImage = extractMetaTag2(head, "property", "og:image");
+  meta.robots = extractMetaTag2(head, "name", "robots");
+  const canonicalMatch = head.match(/<link\s[^>]*rel=["']canonical["'][^>]*href=["']([^"']+)["']/) || head.match(/<link\s[^>]*href=["']([^"']+)["'][^>]*rel=["']canonical["']/);
+  if (canonicalMatch) meta.canonical = canonicalMatch[1];
+  if (!meta.description && hasDynamicMeta(head, "name", "description")) meta.description = "[detected]";
+  if (!meta.ogTitle && hasDynamicMeta(head, "property", "og:title")) meta.ogTitle = "[detected]";
+  if (!meta.ogDescription && hasDynamicMeta(head, "property", "og:description")) meta.ogDescription = "[detected]";
+  if (!meta.ogImage && hasDynamicMeta(head, "property", "og:image")) meta.ogImage = "[detected]";
+  if (!meta.robots && hasDynamicMeta(head, "name", "robots")) meta.robots = "[detected]";
+  if (/application\/ld\+json/.test(head)) {
     meta.structuredData = [{ "@context": "https://schema.org", "@type": "detected" }];
   }
-  if (/viewport\s*[:=]/.test(source)) {
-    meta.viewport = "detected";
-  }
-  if (/icons\s*:\s*\{/.test(metaBlock) || /favicon/.test(metaBlock)) {
-    meta.favicon = "detected";
-  }
   return meta;
 }
-function createEmptyMetadata() {
+function extractMetaTag2(html, attr, name) {
+  const r1 = new RegExp(`<meta\\s[^>]*${attr}=["']${name}["'][^>]*content=["']([^"']+)["']`);
+  const m1 = html.match(r1);
+  if (m1) return m1[1];
+  const r2 = new RegExp(`<meta\\s[^>]*content=["']([^"']+)["'][^>]*${attr}=["']${name}["']`);
+  const m2 = html.match(r2);
+  if (m2) return m2[1];
+  return null;
+}
+function hasDynamicMeta(html, attr, name) {
+  const r1 = new RegExp(`<meta\\s[^>]*${attr}=["']${name}["'][^>]*content=\\{`);
+  const r2 = new RegExp(`<meta\\s[^>]*content=\\{[^}]*\\}[^>]*${attr}=["']${name}["']`);
+  return r1.test(html) || r2.test(html);
+}
+function createEmptyMetadata5() {
   return {
     title: null,
     description: null,
@@ -631,7 +1610,7 @@ function createEmptyMetadata() {
     favicon: null
   };
 }
-function mergeMetadata(target, source) {
+function mergeMetadata5(target, source) {
   for (const key of Object.keys(source)) {
     if (target[key] === null || target[key] === void 0) {
       target[key] = source[key];
@@ -639,23 +1618,22 @@ function mergeMetadata(target, source) {
   }
 }
 
-// src/config.ts
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile5 } from "fs/promises";
-import { join as join5 } from "path";
-var CONFIG_FILES = [".indxelrc.json", ".indxelrc", "indxel.config.json"];
-async function loadConfig(cwd) {
-  for (const file of CONFIG_FILES) {
-    const path = join5(cwd, file);
-    if (existsSync4(path)) {
-      try {
-        const content = await readFile5(path, "utf-8");
-        return JSON.parse(content);
-      } catch {
-      }
-    }
+// src/scan.ts
+async function scanProject(framework, projectRoot, appDir) {
+  switch (framework) {
+    case "nextjs":
+      return scanPages(projectRoot, appDir);
+    case "nuxt":
+      return scanNuxtPages(projectRoot, appDir);
+    case "remix":
+      return scanRemixPages(projectRoot, appDir);
+    case "astro":
+      return scanAstroPages(projectRoot, appDir);
+    case "sveltekit":
+      return scanSvelteKitPages(projectRoot, appDir);
+    default:
+      return [];
   }
-  return {};
 }
 
 // src/formatter.ts
@@ -946,7 +1924,7 @@ function formatMetadataObject(meta) {
 }
 
 // src/commands/check.ts
-var checkCommand = new Command2("check").description("Audit SEO metadata for all pages in your project").option("--cwd <path>", "Project directory", process.cwd()).option("--ci", "CI/CD mode \u2014 strict, exit 1 on any error", false).option("--diff", "Compare with previous check run", false).option("--json", "Output results as JSON", false).option("--strict", "Treat warnings as errors", false).option("--min-score <score>", "Minimum score to pass (0-100, default: exit on any error)").option("--fix", "Show suggested metadata code to fix errors", false).action(async (opts) => {
+var checkCommand = new Command2("check").description("Audit SEO metadata for all pages in your project").option("--cwd <path>", "Project directory", process.cwd()).option("--ci", "CI/CD mode \u2014 strict, exit 1 on any error", false).option("--diff", "Compare with previous check run", false).option("--json", "Output results as JSON", false).option("--strict", "Treat warnings as errors", false).option("--min-score <score>", "Minimum score to pass (0-100, default: exit on any error)").option("--fix", "Show suggested metadata code to fix errors", false).option("--push", "Push results to Indxel dashboard", false).option("--api-key <key>", "API key for --push (or set INDXEL_API_KEY env var)").action(async (opts) => {
   const cwd = opts.cwd;
   const isCI = opts.ci;
   const isStrict = opts.strict || isCI;
@@ -957,33 +1935,45 @@ var checkCommand = new Command2("check").description("Audit SEO metadata for all
   const minScore = opts.minScore ? parseInt(opts.minScore, 10) : config.minScore ?? null;
   const spinner = ora2("Detecting project...").start();
   const project = await detectProject(cwd);
-  if (!project.isNextJs) {
-    spinner.fail("Not a Next.js project");
+  if (project.framework === "unknown") {
+    spinner.fail("No supported framework detected");
     if (!jsonOutput) {
-      console.log(chalk4.dim("  Run this command from a Next.js project root."));
+      console.log(chalk4.dim("  Supported: Next.js, Nuxt, Remix, Astro, SvelteKit."));
+      console.log(chalk4.dim("  For any live site, use: npx indxel crawl <url>"));
     }
     process.exit(1);
   }
   if (!project.usesAppRouter) {
-    spinner.fail("App Router not detected");
+    spinner.fail(`No pages directory detected for ${frameworkLabel(project.framework)}`);
     if (!jsonOutput) {
-      console.log(chalk4.dim("  indxel requires Next.js App Router (src/app or app directory)."));
+      const hints = {
+        nextjs: "indxel requires Next.js App Router (src/app or app directory).",
+        nuxt: "indxel requires a pages/ directory for Nuxt.",
+        remix: "indxel requires an app/routes/ directory for Remix.",
+        astro: "indxel requires a src/pages/ directory for Astro.",
+        sveltekit: "indxel requires a src/routes/ directory for SvelteKit.",
+        unknown: ""
+      };
+      console.log(chalk4.dim(`  ${hints[project.framework]}`));
     }
     process.exit(1);
   }
-  spinner.text = "Scanning pages...";
-  const allPages = await scanPages(cwd, project.appDir);
+  const label = frameworkLabel(project.framework);
+  const version = project.frameworkVersion ? ` ${project.frameworkVersion}` : "";
+  spinner.succeed(`Detected ${label}${version}`);
+  const scanSpinner = ora2("Scanning pages...").start();
+  const allPages = await scanProject(project.framework, cwd, project.appDir);
   if (allPages.length === 0) {
-    spinner.fail("No pages found");
+    scanSpinner.fail("No pages found");
     if (!jsonOutput) {
-      console.log(chalk4.dim(`  No page.tsx/ts files found in ${project.appDir}/`));
+      console.log(chalk4.dim(`  No page files found in ${project.appDir}/`));
     }
     process.exit(1);
   }
   const ignoreRoutes = config.ignoreRoutes ?? [];
   const pages = ignoreRoutes.length > 0 ? allPages.filter((p) => !ignoreRoutes.some((pattern) => matchRoute(p.route, pattern))) : allPages;
   const ignoredCount = allPages.length - pages.length;
-  spinner.succeed(`Found ${allPages.length} page${allPages.length > 1 ? "s" : ""}${ignoredCount > 0 ? ` (${ignoredCount} ignored)` : ""}`);
+  scanSpinner.succeed(`Found ${allPages.length} page${allPages.length > 1 ? "s" : ""}${ignoredCount > 0 ? ` (${ignoredCount} ignored)` : ""}`);
   const staticPages = pages.filter((p) => !p.hasDynamicMetadata);
   const dynamicPages = pages.filter((p) => p.hasDynamicMetadata);
   if (!jsonOutput) {
@@ -1039,6 +2029,70 @@ var checkCommand = new Command2("check").description("Audit SEO metadata for all
       }
     }
   }
+  if (opts.push) {
+    const apiKey = await resolveApiKey(opts.apiKey);
+    if (!apiKey) {
+      if (!jsonOutput) {
+        console.log(chalk4.yellow("  \u26A0") + " To push results to your dashboard, link your project first:");
+        console.log("");
+        console.log(chalk4.bold("    npx indxel link"));
+        console.log("");
+        console.log(chalk4.dim("  Or use --api-key / set INDXEL_API_KEY."));
+        console.log("");
+      }
+    } else {
+      const pushSpinner = jsonOutput ? null : ora2("Pushing results to Indxel...").start();
+      try {
+        const pushUrl = process.env.INDXEL_API_URL || "https://indxel.com";
+        const res = await fetch(`${pushUrl}/api/cli/push`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            type: "check",
+            check: {
+              score: summary.averageScore,
+              grade: summary.grade,
+              totalPages: summary.totalPages,
+              passedPages: summary.passedPages,
+              criticalErrors: summary.criticalErrors,
+              optionalErrors: summary.optionalErrors,
+              pages: summary.results.map((r) => ({
+                route: r.page.route,
+                score: r.validation.score,
+                errors: r.validation.errors.length,
+                warnings: r.validation.warnings.length
+              }))
+            }
+          })
+        });
+        if (res.ok) {
+          const data = await res.json();
+          if (pushSpinner) pushSpinner.succeed(`Pushed to dashboard \u2014 check ${data.checkId}`);
+          if (data.usage && !jsonOutput) {
+            const pct = Math.round(data.usage.used / data.usage.limit * 100);
+            const usageColor = pct >= 80 ? chalk4.yellow : chalk4.dim;
+            console.log(usageColor(`  Usage: ${data.usage.used}/${data.usage.limit} checks this month (${pct}%)`));
+          }
+        } else {
+          const data = await res.json().catch(() => ({}));
+          if (pushSpinner) pushSpinner.fail(`Push failed: ${data.error || res.statusText}`);
+        }
+      } catch (err) {
+        if (pushSpinner) pushSpinner.fail(`Push failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (!jsonOutput) console.log("");
+    }
+  }
+  if (!jsonOutput && !isCI) {
+    if (!opts.push) {
+      console.log(chalk4.dim("  Save to dashboard   \u2192 ") + chalk4.bold("npx indxel check --push"));
+    }
+    console.log(chalk4.dim("  Guard deploys       \u2192 ") + chalk4.bold("npx indxel init --hook"));
+    console.log("");
+  }
   if (minScore !== null) {
     if (summary.averageScore < minScore) {
       if (!jsonOutput) {
@@ -1077,11 +2131,25 @@ function scoreColor(score) {
   if (score >= 70) return chalk5.yellow;
   return chalk5.red;
 }
-var crawlCommand = new Command3("crawl").description("Crawl a live site, audit every page, check sitemap, robots.txt, and assets").argument("<url>", "URL to start crawling (e.g., https://yoursite.com)").option("--max-pages <n>", "Maximum pages to crawl", "200").option("--max-depth <n>", "Maximum link depth", "5").option("--delay <ms>", "Delay between requests in ms", "200").option("--json", "Output results as JSON", false).option("--strict", "Treat warnings as errors", false).option("--skip-assets", "Skip asset verification", false).option("--skip-sitemap", "Skip sitemap check", false).option("--skip-robots", "Skip robots.txt check", false).option("--ignore <patterns>", "Comma-separated path patterns to exclude from analysis (e.g. /app/*,/admin/*)").option("--push", "Push results to Indxel dashboard", false).option("--api-key <key>", "API key for --push (or set INDXEL_API_KEY env var)").action(async (url, opts) => {
+var crawlCommand = new Command3("crawl").description("Crawl a live site, audit every page, check sitemap, robots.txt, and assets").argument("[url]", "URL to start crawling (auto-detected from seo.config if omitted)").option("--max-pages <n>", "Maximum pages to crawl", "500").option("--max-depth <n>", "Maximum link depth", "5").option("--delay <ms>", "Delay between requests in ms", "200").option("--json", "Output results as JSON", false).option("--strict", "Treat warnings as errors", false).option("--skip-assets", "Skip asset verification", false).option("--skip-sitemap", "Skip sitemap check", false).option("--skip-robots", "Skip robots.txt check", false).option("--ignore <patterns>", "Comma-separated path patterns to exclude from analysis (e.g. /app/*,/admin/*)").option("--push", "Push results to Indxel dashboard", false).option("--api-key <key>", "API key for --push (or set INDXEL_API_KEY env var)").action(async (urlArg, opts) => {
   const jsonOutput = opts.json;
-  const maxPages = parseInt(opts.maxPages, 10);
   const maxDepth = parseInt(opts.maxDepth, 10);
   const delay4 = parseInt(opts.delay, 10);
+  const maxPages = parseInt(opts.maxPages, 10);
+  let url = urlArg;
+  if (!url) {
+    const detected = await resolveProjectUrl(process.cwd());
+    if (detected) {
+      url = detected;
+      if (!jsonOutput) {
+        console.log(chalk5.dim(`  Using URL from project config: ${url}`));
+      }
+    } else {
+      console.error(chalk5.red("  No URL provided and none found in seo.config or .indxelrc.json."));
+      console.error(chalk5.dim("  Usage: npx indxel crawl [url]"));
+      process.exit(1);
+    }
+  }
   if (!url.startsWith("http://") && !url.startsWith("https://")) {
     url = `https://${url}`;
   }
@@ -1417,6 +2485,7 @@ var crawlCommand = new Command3("crawl").description("Crawl a live site, audit e
             Authorization: `Bearer ${apiKey}`
           },
           body: JSON.stringify({
+            url,
             crawl: crawlResult,
             robots: robotsResult,
             sitemap: sitemapComparison,
@@ -1436,6 +2505,11 @@ var crawlCommand = new Command3("crawl").description("Crawl a live site, audit e
       if (!jsonOutput) console.log("");
     }
   }
+  if (!opts.push && !jsonOutput) {
+    console.log(chalk5.dim("  Save & compare crawls \u2192 ") + chalk5.bold("npx indxel crawl --push"));
+    console.log(chalk5.dim("  Submit to Google       \u2192 ") + chalk5.bold("npx indxel index"));
+    console.log("");
+  }
   if (crawlResult.totalErrors > 0) {
     process.exit(1);
   }
@@ -1446,8 +2520,20 @@ import { Command as Command4 } from "commander";
 import chalk6 from "chalk";
 import ora4 from "ora";
 import { researchKeywords, crawlSite as crawlSite2, analyzeContentGaps } from "indxel";
-var keywordsCommand = new Command4("keywords").description("Research keyword opportunities and find content gaps").argument("<seed>", "Seed keyword or topic to research").option("--locale <locale>", "Language locale", "en").option("--country <country>", "Country code", "us").option("--site <url>", "Site URL to analyze content gaps against").option("--max-pages <n>", "Maximum pages to crawl for gap analysis", "30").option("--json", "Output results as JSON", false).action(async (seed, opts) => {
+var keywordsCommand = new Command4("keywords").description("Research keyword opportunities and find content gaps").argument("<seed>", "Seed keyword or topic to research").option("--locale <locale>", "Language locale", "en").option("--country <country>", "Country code", "us").option("--site <url>", "Site URL to analyze content gaps against").option("--max-pages <n>", "Maximum pages to crawl for gap analysis", "30").option("--api-key <key>", "Indxel API key (or set INDXEL_API_KEY / run npx indxel link)").option("--json", "Output results as JSON", false).action(async (seed, opts) => {
   const jsonOutput = opts.json;
+  const apiKey = await resolveApiKey(opts.apiKey);
+  if (!apiKey) {
+    console.log("");
+    console.log(chalk6.bold("  indxel keywords") + chalk6.dim(" \u2014 requires a free account"));
+    console.log("");
+    console.log(chalk6.dim("  Keyword research is free but requires a linked project."));
+    console.log(chalk6.dim("  Create a free account in 30 seconds:"));
+    console.log("");
+    console.log(chalk6.bold("    npx indxel link"));
+    console.log("");
+    process.exit(1);
+  }
   if (!jsonOutput) {
     console.log("");
     console.log(chalk6.bold(`  indxel keywords`) + chalk6.dim(` \u2014 "${seed}"`));
@@ -1541,6 +2627,10 @@ var keywordsCommand = new Command4("keywords").description("Research keyword opp
       }
     }
   }
+  if (!jsonOutput && !opts.site) {
+    console.log(chalk6.dim("  Find content gaps \u2192 ") + chalk6.bold(`npx indxel keywords "${seed}" --site yoursite.com`));
+    console.log("");
+  }
   if (jsonOutput) {
     console.log(
       JSON.stringify(
@@ -1578,7 +2668,7 @@ async function checkPlan(apiKey) {
 function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var indexCommand = new Command5("index").description("Submit your pages to search engines and check indexation status").argument("<url>", "Site URL (e.g., https://yoursite.com)").option("--check", "Check which pages appear indexed (Pro+)", false).option("--indexnow-key <key>", "IndexNow key (auto-detected from .indxel/ if not specified)").option("--api-key <key>", "Indxel API key (required for --check and IndexNow submission)").option("--json", "Output results as JSON", false).action(async (url, opts) => {
+var indexCommand = new Command5("index").description("Submit your pages to search engines and check indexation status").argument("[url]", "Site URL (auto-detected from seo.config if omitted)").option("--check", "Check which pages appear indexed (Pro+)", false).option("--indexnow-key <key>", "IndexNow key (auto-detected from .indxel/ if not specified)").option("--api-key <key>", "Indxel API key (required for --check and IndexNow submission)").option("--json", "Output results as JSON", false).action(async (urlArg, opts) => {
   const jsonOutput = opts.json;
   const needsPaid = opts.check;
   function log(...args) {
@@ -1587,6 +2677,18 @@ var indexCommand = new Command5("index").description("Submit your pages to searc
   function spin(text) {
     return jsonOutput ? null : ora5(text).start();
   }
+  let url = urlArg;
+  if (!url) {
+    const detected = await resolveProjectUrl(process.cwd());
+    if (detected) {
+      url = detected;
+      log(chalk7.dim(`  Using URL from project config: ${url}`));
+    } else {
+      console.error(chalk7.red("  No URL provided and none found in seo.config or .indxelrc.json."));
+      console.error(chalk7.dim("  Usage: npx indxel index [url]"));
+      process.exit(1);
+    }
+  }
   if (!url.startsWith("http://") && !url.startsWith("https://")) {
     url = `https://${url}`;
   }
@@ -1826,7 +2928,29 @@ function scoreColor2(score) {
 function delay2(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-async function fetchPsi(url, strategy) {
+async function fetchPsi(url, strategy, apiKey) {
+  if (apiKey) {
+    const backendUrl = process.env.INDXEL_API_URL || "https://indxel.com";
+    const res = await fetch(`${backendUrl}/api/cli/perf`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ url, strategy }),
+      signal: AbortSignal.timeout(6e4)
+    });
+    if (res.ok) {
+      return await res.json();
+    }
+    if (res.status === 401 || res.status === 403) {
+      const data = await res.json().catch(() => ({ error: "Auth failed" }));
+      throw new Error(data.error || `Backend returned ${res.status}`);
+    }
+  }
+  return fetchPsiDirect(url, strategy);
+}
+async function fetchPsiDirect(url, strategy) {
   const params = new URLSearchParams({
     url,
     strategy,
@@ -1850,6 +2974,29 @@ function parsePsiResponse(data) {
   if (!lr) throw new Error("No lighthouseResult in PSI response");
   const perfScore = lr.categories?.performance?.score;
   if (perfScore == null) throw new Error("No performance score in PSI response");
+  const diagnostics = [];
+  const auditRefs = lr.categories?.performance?.auditRefs ?? [];
+  const metricIds = /* @__PURE__ */ new Set([
+    "largest-contentful-paint",
+    "cumulative-layout-shift",
+    "interaction-to-next-paint",
+    "first-contentful-paint",
+    "speed-index",
+    "total-blocking-time"
+  ]);
+  for (const ref of auditRefs) {
+    if (metricIds.has(ref.id)) continue;
+    if (ref.group !== "diagnostics" && ref.group !== "load-opportunities" && ref.group !== "budgets") continue;
+    const audit = lr.audits?.[ref.id];
+    if (!audit || audit.score === 1 || audit.scoreDisplayMode === "notApplicable") continue;
+    diagnostics.push({
+      id: ref.id,
+      title: audit.title ?? ref.id,
+      displayValue: audit.displayValue || void 0,
+      savingsMs: audit.details?.overallSavingsMs
+    });
+  }
+  diagnostics.sort((a, b) => (b.savingsMs ?? 0) - (a.savingsMs ?? 0));
   return {
     performanceScore: Math.round(perfScore * 100),
     lcp: lr.audits?.["largest-contentful-paint"]?.numericValue ?? 0,
@@ -1857,7 +3004,8 @@ function parsePsiResponse(data) {
     inp: lr.audits?.["interaction-to-next-paint"]?.numericValue ?? 0,
     fcp: lr.audits?.["first-contentful-paint"]?.numericValue ?? 0,
     si: lr.audits?.["speed-index"]?.numericValue ?? 0,
-    tbt: lr.audits?.["total-blocking-time"]?.numericValue ?? 0
+    tbt: lr.audits?.["total-blocking-time"]?.numericValue ?? 0,
+    diagnostics
   };
 }
 function checkBudgets(metrics, budgets) {
@@ -1921,6 +3069,16 @@ function printPageResult(result) {
     `    ${formatMs(metrics.tbt).padEnd(9)} ${chalk8.dim("TBT  Total Blocking Time")}`
   );
   console.log("");
+  if (metrics.diagnostics.length > 0) {
+    console.log(chalk8.bold("  Diagnostics"));
+    for (const d of metrics.diagnostics) {
+      const icon = d.savingsMs != null && d.savingsMs > 0 ? chalk8.yellow("\u26A1") : chalk8.dim("\u2139");
+      const savings = d.savingsMs != null && d.savingsMs > 0 ? chalk8.yellow(` -${formatMs(d.savingsMs)}`) : "";
+      const display = d.displayValue ? chalk8.dim(` (${d.displayValue})`) : "";
+      console.log(`  ${icon} ${d.title}${display}${savings}`);
+    }
+    console.log("");
+  }
 }
 function printMultiPageSummary(results) {
   const valid = results.filter((r) => r.metrics);
@@ -1951,7 +3109,7 @@ function printMultiPageSummary(results) {
   );
   console.log("");
 }
-var perfCommand = new Command6("perf").description("Test Core Web Vitals and performance via PageSpeed Insights").argument("<url>", "URL to test (e.g., https://yoursite.com)").option(
+var perfCommand = new Command6("perf").description("Test Core Web Vitals and performance via PageSpeed Insights").argument("[url]", "URL to test (auto-detected from seo.config if omitted)").option(
   "--strategy <strategy>",
   "Testing strategy: mobile or desktop",
   "mobile"
@@ -1959,16 +3117,32 @@ var perfCommand = new Command6("perf").description("Test Core Web Vitals and per
   "--pages <n>",
   "Test top N pages from sitemap (default: 1 = just the URL)",
   "1"
-).option("--json", "Output results as JSON", false).option("--budget-lcp <ms>", "Fail if LCP exceeds threshold (ms)").option("--budget-cls <score>", "Fail if CLS exceeds threshold").option("--budget-score <n>", "Fail if perf score below threshold").action(async (url, opts) => {
+).option("--json", "Output results as JSON", false).option("--budget-lcp <ms>", "Fail if LCP exceeds threshold (ms)").option("--budget-cls <score>", "Fail if CLS exceeds threshold").option("--budget-score <n>", "Fail if perf score below threshold").option("--api-key <key>", "Indxel API key (uses our backend for PSI, or set INDXEL_API_KEY)").action(async (urlArg, opts) => {
   const jsonOutput = opts.json;
   const strategy = opts.strategy;
   const pageCount = parseInt(opts.pages, 10);
+  const apiKey = await resolveApiKey(opts.apiKey);
   if (strategy !== "mobile" && strategy !== "desktop") {
     console.error(
       chalk8.red("  --strategy must be 'mobile' or 'desktop'")
     );
     process.exit(1);
   }
+  let url = urlArg;
+  if (!url) {
+    const detected = await resolveProjectUrl(process.cwd());
+    if (detected) {
+      url = detected;
+      if (!jsonOutput) {
+        console.log(chalk8.dim(`  Using URL from project config: ${url}`));
+        console.log("");
+      }
+    } else {
+      console.error(chalk8.red("  No URL provided and none found in seo.config or .indxelrc.json."));
+      console.error(chalk8.dim("  Usage: npx indxel perf [url]"));
+      process.exit(1);
+    }
+  }
   if (!url.startsWith("http://") && !url.startsWith("https://")) {
     url = `https://${url}`;
   }
@@ -1999,7 +3173,7 @@ var perfCommand = new Command6("perf").description("Test Core Web Vitals and per
       urls.length > 1 ? `Testing ${i + 1}/${urls.length}: ${targetUrl}` : `Testing ${targetUrl} (${strategy})...`
     ).start();
     try {
-      const metrics = await fetchPsi(targetUrl, strategy);
+      const metrics = await fetchPsi(targetUrl, strategy, apiKey);
       spinner?.stop();
       results.push({ url: targetUrl, strategy, metrics });
       if (!jsonOutput) {
@@ -2084,6 +3258,11 @@ var perfCommand = new Command6("perf").description("Test Core Web Vitals and per
       process.exit(1);
     }
   }
+  if (!jsonOutput && !hasBudgets) {
+    console.log(chalk8.dim("  Enforce budgets in CI \u2192 ") + chalk8.bold("npx indxel perf --budget-score 80 --budget-lcp 2500"));
+    console.log(chalk8.dim("  Full SEO + perf audit \u2192 ") + chalk8.bold("npx indxel crawl"));
+    console.log("");
+  }
 });
 
 // src/commands/link.ts
@@ -2095,11 +3274,15 @@ function delay3(ms) {
 }
 async function openBrowser(url) {
   const { platform } = process;
-  const { exec } = await import("child_process");
-  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-  exec(`${cmd} ${url}`);
+  const { execFile } = await import("child_process");
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  if (platform === "win32") {
+    execFile(cmd, ["/c", "start", "", url]);
+  } else {
+    execFile(cmd, [url]);
+  }
 }
-var linkCommand = new Command7("link").description("Link this project to your Indxel dashboard for monitoring").option("--api-key <key>", "Link directly with an API key (skip browser flow)").action(async (opts) => {
+var linkCommand = new Command7("link").description("Link this project to your Indxel dashboard for monitoring").option("--api-key <key>", "Link directly with an account API key (skip browser flow)").action(async (opts) => {
   const apiUrl = process.env.INDXEL_API_URL || "https://indxel.com";
   const cwd = process.cwd();
   console.log("");
@@ -2116,7 +3299,7 @@ var linkCommand = new Command7("link").description("Link this project to your In
     return;
   }
   if (opts.apiKey) {
-    const spinner = ora7("Verifying API key...").start();
+    const spinner = ora7("Fetching projects...").start();
     try {
       const res = await fetch(`${apiUrl}/api/projects/by-key`, {
         headers: { Authorization: `Bearer ${opts.apiKey}` },
@@ -2129,15 +3312,48 @@ var linkCommand = new Command7("link").description("Link this project to your In
         process.exit(1);
       }
       const body = await res.json();
-      const project = body.project;
-      spinner.succeed(`Linked to ${chalk9.bold(project.name)}`);
-      await saveProjectConfig(cwd, {
-        apiKey: opts.apiKey,
-        projectId: project.id,
-        projectName: project.name,
-        linkedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      await syncIndexNowKey(cwd, apiUrl, opts.apiKey, project.id);
+      const projects = body.projects;
+      if (projects.length === 0) {
+        spinner.fail("No projects found. Create one at https://indxel.com/dashboard first.");
+        console.log("");
+        process.exit(1);
+      }
+      const detectedUrl = await resolveProjectUrl(cwd);
+      let matched = detectedUrl ? projects.find((p) => normalizeUrl(p.url) === normalizeUrl(detectedUrl)) : null;
+      if (!matched && projects.length === 1) {
+        matched = projects[0];
+      }
+      if (matched) {
+        spinner.succeed(`Linked to ${chalk9.bold(matched.name)}`);
+        await saveProjectConfig(cwd, {
+          apiKey: opts.apiKey,
+          projectId: matched.id,
+          projectName: matched.name,
+          linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await syncIndexNowKey(cwd, apiUrl, opts.apiKey, matched.id);
+      } else {
+        spinner.stop();
+        console.log(chalk9.bold("  Multiple projects found. Pick one:"));
+        console.log("");
+        projects.forEach((p, i) => {
+          console.log(`  ${chalk9.bold(`${i + 1}.`)} ${p.name} ${chalk9.dim(`(${p.url})`)}`);
+        });
+        console.log("");
+        console.log(chalk9.dim("  Re-run with the project URL matching your codebase,"));
+        console.log(chalk9.dim("  or add a seo.config.ts with your site URL."));
+        console.log("");
+        const project = projects[0];
+        const linkSpinner = ora7(`Linking to ${project.name}...`).start();
+        await saveProjectConfig(cwd, {
+          apiKey: opts.apiKey,
+          projectId: project.id,
+          projectName: project.name,
+          linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await syncIndexNowKey(cwd, apiUrl, opts.apiKey, project.id);
+        linkSpinner.succeed(`Linked to ${chalk9.bold(project.name)}`);
+      }
       console.log("");
       console.log(chalk9.dim("  Config saved to .indxel/config.json"));
       console.log(chalk9.dim("  You can now use ") + chalk9.bold("npx indxel crawl --push") + chalk9.dim(" without --api-key."));
@@ -2227,6 +3443,9 @@ var linkCommand = new Command7("link").description("Link this project to your In
   console.log("");
   process.exit(1);
 });
+function normalizeUrl(url) {
+  return url.replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/+$/, "").toLowerCase();
+}
 async function syncIndexNowKey(cwd, apiUrl, apiKey, projectId) {
   const indexNowKey = await loadIndexNowKey(cwd);
   if (!indexNowKey) return;
@@ -2248,9 +3467,10 @@ async function syncIndexNowKey(cwd, apiUrl, apiKey, projectId) {
 }
 
 // src/index.ts
+var cliVersion = true ? "0.4.0" : "0.3.1";
 function createProgram() {
   const program2 = new Command8();
-  program2.name("indxel").description("Infrastructure SEO developer-first. ESLint pour le SEO.").version("0.1.0");
+  program2.name("indxel").description("Infrastructure SEO developer-first. ESLint pour le SEO.").version(cliVersion);
   program2.addCommand(initCommand);
   program2.addCommand(checkCommand);
   program2.addCommand(crawlCommand);