@rankcli/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,1901 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/init.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var FRAMEWORKS = [
+  { pattern: "next.config", name: "Next.js" },
+  { pattern: "astro.config", name: "Astro" },
+  { pattern: "nuxt.config", name: "Nuxt" },
+  { pattern: "svelte.config", name: "SvelteKit" },
+  { pattern: "gatsby-config", name: "Gatsby" },
+  { pattern: "vite.config", name: "Vite" },
+  { pattern: "hugo.toml", name: "Hugo" },
+  { pattern: "_config.yml", name: "Jekyll" },
+  { pattern: "angular.json", name: "Angular" },
+  { pattern: "vue.config", name: "Vue CLI" }
+];
+function detectFramework() {
+  const cwd = process.cwd();
+  for (const fw of FRAMEWORKS) {
+    const patterns = [
+      `${fw.pattern}.js`,
+      `${fw.pattern}.ts`,
+      `${fw.pattern}.mjs`,
+      `${fw.pattern}.cjs`,
+      fw.pattern
+    ];
+    for (const p of patterns) {
+      if ((0, import_fs.existsSync)((0, import_path.join)(cwd, p))) {
+        return fw.name;
+      }
+    }
+  }
+  const pkgPath = (0, import_path.join)(cwd, "package.json");
+  if ((0, import_fs.existsSync)(pkgPath)) {
+    try {
+      const pkg = JSON.parse((0, import_fs.readFileSync)(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps["next"]) return "Next.js";
+      if (deps["astro"]) return "Astro";
+      if (deps["nuxt"]) return "Nuxt";
+      if (deps["@sveltejs/kit"]) return "SvelteKit";
+      if (deps["gatsby"]) return "Gatsby";
+      if (deps["react"]) return "React";
+      if (deps["vue"]) return "Vue";
+    } catch {
+    }
+  }
+  return null;
+}
+function getProjectName() {
+  const cwd = process.cwd();
+  const pkgPath = (0, import_path.join)(cwd, "package.json");
+  if ((0, import_fs.existsSync)(pkgPath)) {
+    try {
+      const pkg = JSON.parse((0, import_fs.readFileSync)(pkgPath, "utf-8"));
+      if (pkg.name) return pkg.name;
+    } catch {
+    }
+  }
+  return cwd.split("/").pop() || "unknown";
+}
+async function init(options) {
+  console.log("\n\u{1F680} Initializing SEO Autopilot...\n");
+  const configPath = (0, import_path.join)(process.cwd(), "seo-autopilot.config.json");
+  if ((0, import_fs.existsSync)(configPath)) {
+    console.log("\u26A0\uFE0F  Configuration file already exists: seo-autopilot.config.json");
+    console.log('   Run "seo analyze" to analyze your project.\n');
+    return;
+  }
+  const framework = detectFramework();
+  const projectName = getProjectName();
+  console.log(`\u{1F4E6} Project: ${projectName}`);
+  console.log(`\u{1F527} Framework: ${framework || "Unknown (static site?)"}`);
+  const config2 = {
+    name: projectName,
+    framework,
+    url: null,
+    initialized: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_fs.writeFileSync)(configPath, JSON.stringify(config2, null, 2));
+  console.log("\n\u2705 Created seo-autopilot.config.json");
+  console.log("\n\u{1F4CB} Next steps:");
+  console.log('   1. Run "seo analyze" to analyze your project');
+  console.log('   2. Run "seo audit --url <your-site>" to run a technical audit');
+  console.log("   3. Connect Google Search Console at https://seo-autopilot.dev/connect\n");
+}
+
+// src/commands/analyze.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var CONTENT_EXTENSIONS = [".md", ".mdx", ".html", ".tsx", ".jsx", ".vue", ".astro", ".svelte"];
+function findFiles(dir, extensions, maxDepth = 3, depth = 0) {
+  if (depth > maxDepth) return [];
+  const files = [];
+  try {
+    const items = (0, import_fs2.readdirSync)(dir);
+    for (const item of items) {
+      if (item.startsWith(".") || item === "node_modules" || item === "dist" || item === "build") {
+        continue;
+      }
+      const fullPath = (0, import_path2.join)(dir, item);
+      const stat = (0, import_fs2.statSync)(fullPath);
+      if (stat.isDirectory()) {
+        files.push(...findFiles(fullPath, extensions, maxDepth, depth + 1));
+      } else if (extensions.includes((0, import_path2.extname)(item))) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function extractKeywords(text) {
+  const words = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3);
+  const frequency = {};
+  for (const word of words) {
+    frequency[word] = (frequency[word] || 0) + 1;
+  }
+  const stopWords = /* @__PURE__ */ new Set([
+    "this",
+    "that",
+    "with",
+    "from",
+    "have",
+    "been",
+    "were",
+    "will",
+    "would",
+    "could",
+    "should",
+    "their",
+    "there",
+    "about",
+    "which",
+    "when",
+    "what",
+    "your",
+    "more",
+    "some",
+    "just",
+    "into",
+    "over",
+    "such",
+    "only",
+    "than",
+    "them",
+    "then",
+    "these",
+    "most",
+    "other",
+    "also",
+    "being",
+    "after",
+    "const",
+    "function",
+    "return",
+    "import",
+    "export",
+    "default",
+    "true",
+    "false"
+  ]);
+  return Object.entries(frequency).filter(([word]) => !stopWords.has(word)).sort((a, b) => b[1] - a[1]).slice(0, 20).map(([word]) => word);
+}
+function loadConfig() {
+  const configPath = (0, import_path2.join)(process.cwd(), "seo-autopilot.config.json");
+  if ((0, import_fs2.existsSync)(configPath)) {
+    try {
+      return JSON.parse((0, import_fs2.readFileSync)(configPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function analyze(options) {
+  console.log("\n\u{1F50D} Analyzing project for SEO opportunities...\n");
+  const cwd = process.cwd();
+  const config2 = loadConfig();
+  const result = {
+    projectName: config2?.name || cwd.split("/").pop() || "unknown",
+    framework: config2?.framework || null,
+    hasReadme: false,
+    readmeSummary: null,
+    pageCount: 0,
+    hasMetaTags: false,
+    hasSitemap: false,
+    hasRobotsTxt: false,
+    keywords: [],
+    suggestions: []
+  };
+  const readmePaths = ["README.md", "readme.md", "Readme.md", "README.MD"];
+  for (const rp of readmePaths) {
+    if ((0, import_fs2.existsSync)((0, import_path2.join)(cwd, rp))) {
+      result.hasReadme = true;
+      const content = (0, import_fs2.readFileSync)((0, import_path2.join)(cwd, rp), "utf-8");
+      result.readmeSummary = content.slice(0, 200).replace(/\n/g, " ").trim() + "...";
+      result.keywords.push(...extractKeywords(content));
+      break;
+    }
+  }
+  result.hasSitemap = (0, import_fs2.existsSync)((0, import_path2.join)(cwd, "public", "sitemap.xml")) || (0, import_fs2.existsSync)((0, import_path2.join)(cwd, "sitemap.xml"));
+  result.hasRobotsTxt = (0, import_fs2.existsSync)((0, import_path2.join)(cwd, "public", "robots.txt")) || (0, import_fs2.existsSync)((0, import_path2.join)(cwd, "robots.txt"));
+  const contentFiles = findFiles(cwd, CONTENT_EXTENSIONS);
+  result.pageCount = contentFiles.length;
+  const htmlFiles = contentFiles.filter((f) => f.endsWith(".html") || f.includes("_document") || f.includes("layout"));
+  for (const hf of htmlFiles.slice(0, 5)) {
+    const content = (0, import_fs2.readFileSync)(hf, "utf-8");
+    if (content.includes("<meta") || content.includes("metadata")) {
+      result.hasMetaTags = true;
+      break;
+    }
+  }
+  for (const cf of contentFiles.slice(0, 10)) {
+    const content = (0, import_fs2.readFileSync)(cf, "utf-8");
+    result.keywords.push(...extractKeywords(content));
+  }
+  result.keywords = [...new Set(result.keywords)].slice(0, 20);
+  if (!result.hasReadme) {
+    result.suggestions.push("Add a README.md with clear project description");
+  }
+  if (!result.hasSitemap) {
+    result.suggestions.push("Generate a sitemap.xml for better crawlability");
+  }
+  if (!result.hasRobotsTxt) {
+    result.suggestions.push("Add robots.txt to guide search engine crawlers");
+  }
+  if (!result.hasMetaTags) {
+    result.suggestions.push("Add meta tags (title, description, og:*) to pages");
+  }
+  if (result.pageCount < 5) {
+    result.suggestions.push("Consider adding more content pages for SEO coverage");
+  }
+  console.log("\u{1F4CA} Analysis Results\n");
+  console.log(`Project: ${result.projectName}`);
+  console.log(`Framework: ${result.framework || "Unknown"}`);
+  console.log(`Content files: ${result.pageCount}`);
+  console.log(`Has README: ${result.hasReadme ? "\u2705" : "\u274C"}`);
+  console.log(`Has sitemap.xml: ${result.hasSitemap ? "\u2705" : "\u274C"}`);
+  console.log(`Has robots.txt: ${result.hasRobotsTxt ? "\u2705" : "\u274C"}`);
+  console.log(`Has meta tags: ${result.hasMetaTags ? "\u2705" : "\u274C"}`);
+  if (result.keywords.length > 0) {
+    console.log("\n\u{1F511} Detected Keywords:");
+    console.log(`   ${result.keywords.join(", ")}`);
+  }
+  if (result.suggestions.length > 0) {
+    console.log("\n\u{1F4A1} Suggestions:");
+    for (const s of result.suggestions) {
+      console.log(`   \u2022 ${s}`);
+    }
+  } else {
+    console.log("\n\u2705 No critical SEO issues found!");
+  }
+  console.log('\n\u{1F4C8} Next: Run "seo audit --url <your-deployed-site>" for a full technical audit\n');
+}
+
+// src/commands/audit.ts
+var import_agent_runtime = require("@rankcli/agent-runtime");
+var import_ora = __toESM(require("ora"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/config.ts
+var import_conf = __toESM(require("conf"));
+var import_supabase_js = require("@supabase/supabase-js");
+var SUPABASE_URL = process.env.RANKCLI_SUPABASE_URL || process.env.VITE_SUPABASE_URL || "https://uisqfyeasobjjrgurwnb.supabase.co";
+var SUPABASE_ANON_KEY = process.env.RANKCLI_SUPABASE_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InVpc3FmeWVhc29iampyZ3Vyd25iIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDgwMDc3NjIsImV4cCI6MjA2MzU4Mzc2Mn0.r-GaAqD-OwAKMyH8w7qpAj6P7w52cAPTsb8JfMZmtJE";
+var WEB_APP_URL = process.env.RANKCLI_WEB_URL || "http://localhost:3005";
+var API_URL = process.env.RANKCLI_API_URL || SUPABASE_URL;
+var config = new import_conf.default({
+  projectName: "rankcli",
+  schema: {
+    accessToken: { type: "string" },
+    refreshToken: { type: "string" },
+    expiresAt: { type: "number" },
+    userId: { type: "string" },
+    email: { type: "string" },
+    apiKey: { type: "string" },
+    apiKeyName: { type: "string" },
+    planId: { type: "string" },
+    planName: { type: "string" },
+    sitesLimit: { type: "number" }
+  }
+});
+var supabaseClient = null;
+function getSupabaseClient() {
+  if (!supabaseClient) {
+    supabaseClient = (0, import_supabase_js.createClient)(SUPABASE_URL, SUPABASE_ANON_KEY, {
+      auth: {
+        persistSession: false,
+        // We manage session ourselves via conf
+        autoRefreshToken: false
+      }
+    });
+  }
+  return supabaseClient;
+}
+function isLoggedIn() {
+  const apiKey = process.env.RANKCLI_API_KEY || config.get("apiKey");
+  if (apiKey && apiKey.startsWith("rankcli_")) {
+    return true;
+  }
+  const accessToken = config.get("accessToken");
+  const expiresAt = config.get("expiresAt");
+  if (!accessToken || !expiresAt) {
+    return false;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  return expiresAt > now + 300;
+}
+function isApiKeyAuth() {
+  const apiKey = process.env.RANKCLI_API_KEY || config.get("apiKey");
+  return !!(apiKey && apiKey.startsWith("rankcli_"));
+}
+function getApiKey() {
+  return process.env.RANKCLI_API_KEY || config.get("apiKey") || null;
+}
+function saveApiKey(apiKey, keyName) {
+  config.set("apiKey", apiKey);
+  if (keyName) {
+    config.set("apiKeyName", keyName);
+  }
+}
+async function validateApiKey(apiKey) {
+  try {
+    const response = await fetch(`${API_URL}/functions/v1/validate-api-key`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": apiKey
+      }
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return { valid: false, error: data.error || "Invalid API key" };
+    }
+    return {
+      valid: true,
+      user: data.user,
+      subscription: data.subscription
+    };
+  } catch (err) {
+    return { valid: false, error: err instanceof Error ? err.message : "Validation failed" };
+  }
+}
+async function getSession() {
+  const accessToken = config.get("accessToken");
+  const refreshToken = config.get("refreshToken");
+  const expiresAt = config.get("expiresAt");
+  if (!accessToken || !refreshToken) {
+    return null;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (expiresAt && expiresAt <= now + 300) {
+    const supabase = getSupabaseClient();
+    const { data, error } = await supabase.auth.refreshSession({
+      refresh_token: refreshToken
+    });
+    if (error || !data.session) {
+      clearCredentials();
+      return null;
+    }
+    saveSession(data.session);
+    return data.session;
+  }
+  return {
+    access_token: accessToken,
+    refresh_token: refreshToken,
+    expires_at: expiresAt,
+    expires_in: expiresAt ? expiresAt - now : 0,
+    token_type: "bearer",
+    user: {
+      id: config.get("userId") || "",
+      email: config.get("email"),
+      app_metadata: {},
+      user_metadata: {},
+      aud: "authenticated",
+      created_at: ""
+    }
+  };
+}
+function saveSession(session) {
+  config.set("accessToken", session.access_token);
+  config.set("refreshToken", session.refresh_token);
+  config.set("expiresAt", session.expires_at);
+  config.set("userId", session.user.id);
+  config.set("email", session.user.email);
+}
+function saveSubscription(subscription) {
+  if (subscription.planId !== void 0) config.set("planId", subscription.planId);
+  if (subscription.planName !== void 0) config.set("planName", subscription.planName);
+  if (subscription.sitesLimit !== void 0) config.set("sitesLimit", subscription.sitesLimit);
+}
+function clearCredentials() {
+  config.delete("accessToken");
+  config.delete("refreshToken");
+  config.delete("expiresAt");
+  config.delete("userId");
+  config.delete("email");
+  config.delete("apiKey");
+  config.delete("apiKeyName");
+  config.delete("planId");
+  config.delete("planName");
+  config.delete("sitesLimit");
+}
+function getUserInfo() {
+  return {
+    userId: config.get("userId"),
+    email: config.get("email"),
+    planName: config.get("planName") || "Free",
+    sitesLimit: config.get("sitesLimit") || 1
+  };
+}
+async function getAuthenticatedClient() {
+  const session = await getSession();
+  if (!session) {
+    return null;
+  }
+  const supabase = getSupabaseClient();
+  await supabase.auth.setSession({
+    access_token: session.access_token,
+    refresh_token: session.refresh_token
+  });
+  return supabase;
+}
+
+// src/commands/audit.ts
+var { detectFramework: detectFramework2, getFrameworkDisplayName, getFrameworkIssues } = import_agent_runtime.frameworks;
+async function fetchHtml(url, timeout = 1e4) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "RankCLI-Bot/1.0 (+https://rankcli.dev/bot)",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return null;
+    }
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+async function runAIAnalysis(url, issues, provider, apiKey) {
+  const isAnthropic = provider === "anthropic";
+  const apiUrl = isAnthropic ? "https://api.anthropic.com/v1/messages" : "https://api.openai.com/v1/chat/completions";
+  const prompt = `Analyze these SEO audit results and provide prioritized recommendations:
+
+URL: ${url}
+
+Issues found:
+${issues.map((i) => `- [${i.severity.toUpperCase()}] ${i.code}: ${i.title}`).join("\n")}
+
+Return JSON with:
+{
+  "contentScore": <0-100 overall content quality>,
+  "suggestions": [<3-5 high-impact suggestions>],
+  "prioritizedFixes": [
+    {"code": "<issue code>", "priority": <1-5>, "rationale": "<why fix this first>"}
+  ]
+}`;
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    let body;
+    if (isAnthropic) {
+      headers["x-api-key"] = apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+      body = JSON.stringify({
+        model: "claude-3-haiku-20240307",
+        max_tokens: 1500,
+        messages: [{ role: "user", content: prompt }]
+      });
+    } else {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+      body = JSON.stringify({
+        model: "gpt-4o-mini",
+        messages: [
+          { role: "system", content: "You are an SEO expert. Respond with valid JSON only." },
+          { role: "user", content: prompt }
+        ],
+        max_tokens: 1500,
+        response_format: { type: "json_object" }
+      });
+    }
+    const response = await fetch(apiUrl, { method: "POST", headers, body });
+    if (!response.ok) {
+      console.error(import_chalk.default.yellow(`AI analysis failed: ${response.status}`));
+      return null;
+    }
+    const data = await response.json();
+    const content = isAnthropic ? data.content?.[0]?.text : data.choices?.[0]?.message?.content;
+    if (!content) return null;
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    return JSON.parse(jsonMatch[0]);
+  } catch (error) {
+    console.error(import_chalk.default.yellow(`AI analysis error: ${error}`));
+    return null;
+  }
+}
+function mergeIssues(issueArrays) {
+  const issueMap = /* @__PURE__ */ new Map();
+  for (const issues of issueArrays) {
+    for (const issue of issues) {
+      const existing = issueMap.get(issue.code);
+      if (existing) {
+        const urls = /* @__PURE__ */ new Set([...existing.affectedUrls || [], ...issue.affectedUrls || []]);
+        existing.affectedUrls = Array.from(urls);
+      } else {
+        issueMap.set(issue.code, { ...issue });
+      }
+    }
+  }
+  return Array.from(issueMap.values());
+}
+async function syncToCloud(url, report, mergedIssues, pagesAudited, aiAnalysis) {
+  const supabase = await getAuthenticatedClient();
+  if (!supabase) return null;
+  const { userId, sitesLimit } = getUserInfo();
+  if (!userId) return null;
+  try {
+    const parsedUrl = new URL(url);
+    const domain = parsedUrl.hostname;
+    const { data: existingProject } = await supabase.from("projects").select("id").eq("user_id", userId).eq("domain", domain).eq("is_active", true).single();
+    let projectId;
+    if (existingProject) {
+      projectId = existingProject.id;
+    } else {
+      const { count } = await supabase.from("projects").select("id", { count: "exact", head: true }).eq("user_id", userId).eq("is_active", true);
+      const limit = sitesLimit ?? 1;
+      if (count !== null && count >= limit) {
+        console.log(import_chalk.default.yellow(`
+\u26A0\uFE0F  Project limit reached (${count}/${limit})`));
+        console.log(import_chalk.default.dim(`   Upgrade at: ${WEB_APP_URL}/account`));
+        return null;
+      }
+      const { data: newProject, error: projectError } = await supabase.from("projects").insert({
+        user_id: userId,
+        name: domain,
+        url,
+        domain
+      }).select("id").single();
+      if (projectError || !newProject) {
+        console.error(import_chalk.default.dim("Failed to create project"));
+        return null;
+      }
+      projectId = newProject.id;
+    }
+    const score = report.healthScore?.overall || 0;
+    const healthScores = {
+      overall: score,
+      crawlability: report.healthScore?.crawlability || 0,
+      onPage: report.healthScore?.onPage || 0,
+      content: report.healthScore?.content || 0,
+      performance: report.healthScore?.performance || 0,
+      security: report.healthScore?.security || 0
+    };
+    const { data: audit2, error: auditError } = await supabase.from("audits").insert({
+      project_id: projectId,
+      triggered_by: "cli",
+      triggered_by_user: userId,
+      status: "completed",
+      score,
+      pages_crawled: pagesAudited,
+      issues_found: mergedIssues.length,
+      checks_run: mergedIssues.length > 0 ? 200 : 0,
+      // Approximate
+      health_scores: healthScores,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      summary: {
+        errors: mergedIssues.filter((i) => i.severity === "error").length,
+        warnings: mergedIssues.filter((i) => i.severity === "warning").length,
+        notices: mergedIssues.filter((i) => i.severity === "notice").length,
+        pagesAudited,
+        source: "cli"
+      },
+      ai_analysis: aiAnalysis
+    }).select("id").single();
+    if (auditError || !audit2) {
+      console.error(import_chalk.default.dim("Failed to save audit"));
+      return null;
+    }
+    if (mergedIssues.length > 0) {
+      const issueRecords = mergedIssues.map((issue) => ({
+        audit_id: audit2.id,
+        project_id: projectId,
+        code: issue.code,
+        severity: issue.severity,
+        category: issue.category,
+        title: issue.title,
+        description: issue.description || "",
+        impact: issue.impact || "",
+        how_to_fix: issue.howToFix || "",
+        affected_urls: issue.affectedUrls || [],
+        details: issue.details || {},
+        status: "open"
+      }));
+      await supabase.from("audit_issues").insert(issueRecords);
+    }
+    await supabase.from("projects").update({
+      last_audit_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_audit_score: score
+    }).eq("id", projectId);
+    return { projectId, auditId: audit2.id };
+  } catch (error) {
+    console.error(import_chalk.default.dim("Cloud sync failed"));
+    return null;
+  }
+}
+async function audit(options) {
+  const url = options.url;
+  const maxPages = parseInt(options.maxPages || "5", 10);
+  const enableAI = options.ai || false;
+  const aiProvider = options.aiProvider || "openai";
+  const aiKey = options.aiKey || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || "";
+  const loggedIn = isLoggedIn();
+  if (!url) {
+    console.log("\n\u26A0\uFE0F  Please provide a URL to audit:");
+    console.log("   rankcli audit --url https://your-site.com");
+    console.log("\nOptions:");
+    console.log("   --max-pages <n>     Max pages to crawl (default: 5)");
+    console.log("   --ai                Enable AI analysis");
+    console.log("   --ai-provider <p>   AI provider: openai or anthropic");
+    console.log("   --ai-key <key>      API key (or set OPENAI_API_KEY/ANTHROPIC_API_KEY)");
+    console.log("   --output json       Output as JSON");
+    if (!loggedIn) {
+      console.log(import_chalk.default.dim("\nTip: Log in to sync results to the web dashboard:"));
+      console.log(import_chalk.default.dim("   rankcli login"));
+    }
+    console.log("");
+    return;
+  }
+  try {
+    new URL(url);
+  } catch {
+    console.log("\n\u274C Invalid URL format. Please provide a valid URL.\n");
+    return;
+  }
+  const startTime = Date.now();
+  try {
+    const discoverySpinner = (0, import_ora.default)("Discovering pages...").start();
+    let pagesToAudit = [url];
+    const homepageHtml = await fetchHtml(url, 1e4);
+    let detectedFramework = detectFramework2({});
+    if (homepageHtml) {
+      detectedFramework = detectFramework2({ html: homepageHtml });
+      const discovered = (0, import_agent_runtime.discoverPagesFromLinks)(url, homepageHtml, maxPages - 1);
+      const additionalPages = discovered.map((p) => p.url).filter((u) => u !== url);
+      pagesToAudit = [url, ...additionalPages];
+      const frameworkLabel = detectedFramework.framework !== "unknown" ? ` (${getFrameworkDisplayName(detectedFramework.framework)})` : "";
+      discoverySpinner.succeed(`Discovered ${pagesToAudit.length} pages to audit${frameworkLabel}`);
+    } else {
+      discoverySpinner.warn("Could not fetch homepage, auditing URL only");
+    }
+    const auditSpinner = (0, import_ora.default)(`Auditing ${pagesToAudit.length} pages in parallel...`).start();
+    const auditPage = async (pageUrl, index) => {
+      try {
+        const report = await (0, import_agent_runtime.runFullAudit)({
+          url: pageUrl,
+          maxPages: 1,
+          checkBrokenLinks: options.checkLinks || false
+        });
+        auditSpinner.text = `Auditing pages... (${index + 1}/${pagesToAudit.length} complete)`;
+        return { report, url: pageUrl };
+      } catch (error) {
+        return { report: null, url: pageUrl };
+      }
+    };
+    const parallelStart = Date.now();
+    const auditResults = await Promise.allSettled(
+      pagesToAudit.map((pageUrl, index) => auditPage(pageUrl, index))
+    );
+    const parallelTime = Date.now() - parallelStart;
+    const allIssues = [];
+    let primaryReport = null;
+    let successCount = 0;
+    for (let i = 0; i < auditResults.length; i++) {
+      const result = auditResults[i];
+      if (result.status === "fulfilled" && result.value.report) {
+        allIssues.push(result.value.report.issues);
+        if (i === 0) {
+          primaryReport = result.value.report;
+        }
+        successCount++;
+      }
+    }
+    if (!primaryReport) {
+      auditSpinner.fail("Audit failed - could not analyze any pages");
+      return;
+    }
+    auditSpinner.succeed(`Audited ${successCount}/${pagesToAudit.length} pages in ${parallelTime}ms`);
+    let mergedIssues = mergeIssues(allIssues);
+    if (detectedFramework.framework !== "unknown" && homepageHtml) {
+      try {
+        const frameworkIssues = await getFrameworkIssues(detectedFramework, homepageHtml, url);
+        if (frameworkIssues.length > 0) {
+          mergedIssues = [...mergedIssues, ...frameworkIssues];
+        }
+      } catch {
+      }
+    }
+    let aiAnalysis = null;
+    if (enableAI && aiKey) {
+      const aiSpinner = (0, import_ora.default)(`Running AI analysis (${aiProvider})...`).start();
+      aiAnalysis = await runAIAnalysis(url, mergedIssues, aiProvider, aiKey);
+      if (aiAnalysis) {
+        aiSpinner.succeed("AI analysis complete");
+      } else {
+        aiSpinner.warn("AI analysis failed or returned no results");
+      }
+    } else if (enableAI && !aiKey) {
+      console.log(import_chalk.default.yellow("\n\u26A0\uFE0F  AI analysis requested but no API key provided"));
+      console.log(import_chalk.default.dim("   Set OPENAI_API_KEY or ANTHROPIC_API_KEY, or use --ai-key"));
+    }
+    const totalTime = Date.now() - startTime;
+    const frameworkName = detectedFramework.framework !== "unknown" ? getFrameworkDisplayName(detectedFramework.framework) : null;
+    if (options.output === "json") {
+      const jsonOutput = {
+        url,
+        score: primaryReport.healthScore?.overall || 0,
+        pagesAudited: successCount,
+        totalTime,
+        framework: frameworkName,
+        issues: mergedIssues,
+        healthScores: primaryReport.healthScore,
+        aiAnalysis
+      };
+      console.log(JSON.stringify(jsonOutput, null, 2));
+    } else {
+      console.log("\n" + import_chalk.default.bold("\u2550".repeat(60)));
+      console.log(import_chalk.default.bold.cyan(`  SEO AUDIT REPORT: ${url}`));
+      console.log(import_chalk.default.bold("\u2550".repeat(60)));
+      const score = primaryReport.healthScore?.overall || 0;
+      const scoreColor = score >= 80 ? import_chalk.default.green : score >= 60 ? import_chalk.default.yellow : import_chalk.default.red;
+      console.log(`
+  ${import_chalk.default.bold("Score:")} ${scoreColor.bold(score + "/100")}`);
+      console.log(`  ${import_chalk.default.bold("Pages audited:")} ${successCount}`);
+      console.log(`  ${import_chalk.default.bold("Issues found:")} ${mergedIssues.length}`);
+      console.log(`  ${import_chalk.default.bold("Time:")} ${totalTime}ms`);
+      if (frameworkName) {
+        console.log(`  ${import_chalk.default.bold("Framework:")} ${import_chalk.default.cyan(frameworkName)}`);
+      }
+      if (primaryReport.healthScore) {
+        console.log("\n" + import_chalk.default.bold("  Health Scores:"));
+        const hs = primaryReport.healthScore;
+        const bar = (score2) => {
+          const filled = Math.round(score2 / 5);
+          const empty = 20 - filled;
+          const color = score2 >= 80 ? import_chalk.default.green : score2 >= 60 ? import_chalk.default.yellow : import_chalk.default.red;
+          return color("\u2588".repeat(filled)) + import_chalk.default.gray("\u2591".repeat(empty));
+        };
+        console.log(`    Crawlability:  ${bar(hs.crawlability || 0)} ${hs.crawlability || 0}%`);
+        console.log(`    On-Page:       ${bar(hs.onPage || 0)} ${hs.onPage || 0}%`);
+        console.log(`    Content:       ${bar(hs.content || 0)} ${hs.content || 0}%`);
+        console.log(`    Performance:   ${bar(hs.performance || 0)} ${hs.performance || 0}%`);
+        console.log(`    Security:      ${bar(hs.security || 0)} ${hs.security || 0}%`);
+      }
+      const errors = mergedIssues.filter((i) => i.severity === "error");
+      const warnings = mergedIssues.filter((i) => i.severity === "warning");
+      const notices = mergedIssues.filter((i) => i.severity === "notice");
+      console.log("\n" + import_chalk.default.bold("  Issues by Severity:"));
+      console.log(`    ${import_chalk.default.red("\u25CF")} Errors:   ${errors.length}`);
+      console.log(`    ${import_chalk.default.yellow("\u25CF")} Warnings: ${warnings.length}`);
+      console.log(`    ${import_chalk.default.blue("\u25CF")} Notices:  ${notices.length}`);
+      console.log("\n" + import_chalk.default.bold("  Top Issues:"));
+      const topIssues = [...errors, ...warnings, ...notices].slice(0, 10);
+      topIssues.forEach((issue, i) => {
+        const icon = issue.severity === "error" ? import_chalk.default.red("\u2717") : issue.severity === "warning" ? import_chalk.default.yellow("!") : import_chalk.default.blue("i");
+        console.log(`    ${i + 1}. ${icon} ${issue.title}`);
+        if (issue.affectedUrls && issue.affectedUrls.length > 1) {
+          console.log(import_chalk.default.dim(`       Affects ${issue.affectedUrls.length} pages`));
+        }
+      });
+      if (aiAnalysis) {
+        console.log("\n" + import_chalk.default.bold("  AI Analysis:"));
+        console.log(`    Content Score: ${aiAnalysis.contentScore}/100`);
+        console.log("\n    " + import_chalk.default.bold("Suggestions:"));
+        aiAnalysis.suggestions.forEach((s, i) => {
+          console.log(`    ${i + 1}. ${s}`);
+        });
+        if (aiAnalysis.prioritizedFixes?.length > 0) {
+          console.log("\n    " + import_chalk.default.bold("Priority Fixes:"));
+          aiAnalysis.prioritizedFixes.slice(0, 5).forEach((fix, i) => {
+            console.log(`    ${i + 1}. [P${fix.priority}] ${fix.code}`);
+            console.log(import_chalk.default.dim(`       ${fix.rationale}`));
+          });
+        }
+      }
+      console.log("\n" + import_chalk.default.bold("\u2550".repeat(60)));
+      if (loggedIn) {
+        const syncSpinner = (0, import_ora.default)("Syncing to cloud...").start();
+        const syncResult = await syncToCloud(url, primaryReport, mergedIssues, successCount, aiAnalysis);
+        if (syncResult) {
+          syncSpinner.succeed("Results synced to cloud");
+          console.log(import_chalk.default.cyan(`
+  View and manage issues in the web dashboard:`));
+          console.log(import_chalk.default.bold(`  ${WEB_APP_URL}/dashboard/projects/${syncResult.projectId}
+`));
+        } else {
+          syncSpinner.warn("Could not sync to cloud");
+        }
+      } else {
+        console.log(import_chalk.default.dim("\n  Tip: Log in to sync results and manage issues in the web dashboard:"));
+        console.log(import_chalk.default.dim("       rankcli login\n"));
+      }
+    }
+  } catch (error) {
+    console.log(`
+\u274C Audit failed: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+  }
+}
+
+// src/commands/apply.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_agent_runtime2 = require("@rankcli/agent-runtime");
+var SEVERITY_ICON = {
+  critical: "\u274C",
+  warning: "\u26A0\uFE0F",
+  info: "\u2139\uFE0F"
+};
+function printFix(fix, index) {
+  const icon = SEVERITY_ICON[fix.issue.severity] || "\u2022";
+  console.log(`
+${index + 1}. ${icon} ${fix.issue.message}`);
+  console.log(`   File: ${fix.file}`);
+  if (fix.skipped) {
+    console.log(`   Status: SKIPPED - ${fix.skipReason}`);
+  } else {
+    console.log(`   Explanation: ${fix.explanation}`);
+    if (fix.before) {
+      console.log(`   Before: ${truncate(fix.before, 60)}`);
+    }
+    console.log(`   After: ${truncate(fix.after, 100)}`);
+  }
+}
+function truncate(str, maxLen) {
+  const oneLine = str.replace(/\n/g, " ").trim();
+  if (oneLine.length <= maxLen) return oneLine;
+  return oneLine.substring(0, maxLen - 3) + "...";
+}
+async function apply(options) {
+  const cwd = process.cwd();
+  const configPath = (0, import_path3.join)(cwd, "seo-autopilot.config.json");
+  let config2 = null;
+  if ((0, import_fs3.existsSync)(configPath)) {
+    try {
+      config2 = JSON.parse((0, import_fs3.readFileSync)(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  let url = options.url;
+  if (!url && config2?.url) {
+    url = config2.url;
+  }
+  if (!url) {
+    console.log("\n\u26A0\uFE0F  Please provide a URL to analyze:");
+    console.log("   seo apply --url https://your-site.com");
+    console.log("\n   Or set a URL in your seo-autopilot.config.json\n");
+    return;
+  }
+  try {
+    new URL(url);
+  } catch {
+    console.log("\n\u274C Invalid URL format. Please provide a valid URL.\n");
+    return;
+  }
+  console.log("\n\u{1F680} SEO Autopilot - Apply Fixes");
+  console.log("\u2550".repeat(50));
+  console.log("\n\u{1F50D} Detecting framework...");
+  const frameworkResult = await (0, import_agent_runtime2.detectFramework)({ cwd });
+  const framework = frameworkResult.success ? frameworkResult.data : { name: "Unknown", metaPattern: "html-head" };
+  console.log(`   Framework: ${framework.name}`);
+  console.log(`
+\u{1F50D} Analyzing ${url}...`);
+  let analysis;
+  try {
+    analysis = await (0, import_agent_runtime2.runDirectAnalysis)(url);
+  } catch (error) {
+    console.log(`
+\u274C Analysis failed: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+    return;
+  }
+  console.log(`   Score: ${analysis.score}/100`);
+  console.log(`   Issues found: ${analysis.issues.length}`);
+  if (analysis.issues.length === 0) {
+    console.log("\n\u2705 No issues found! Your site looks great.\n");
+    return;
+  }
+  console.log("\n\u{1F527} Generating fixes...");
+  const fixes = await (0, import_agent_runtime2.generateFixes)(analysis.issues, {
+    cwd,
+    url,
+    framework
+  });
+  const actionableFixes = fixes.filter((f) => !f.skipped);
+  const skippedFixes = fixes.filter((f) => f.skipped);
+  console.log(`   Generated ${actionableFixes.length} actionable fix(es)`);
+  if (skippedFixes.length > 0) {
+    console.log(`   ${skippedFixes.length} issue(s) require manual attention`);
+  }
+  console.log("\n" + "\u2500".repeat(50));
+  console.log("PROPOSED FIXES:");
+  console.log("\u2500".repeat(50));
+  for (let i = 0; i < fixes.length; i++) {
+    printFix(fixes[i], i);
+  }
+  if (options.dryRun) {
+    console.log("\n" + "\u2500".repeat(50));
+    console.log("\u{1F4CB} DRY RUN - No changes were made.");
+    console.log("   Remove --dry-run to apply these fixes.\n");
+    return;
+  }
+  if (actionableFixes.length === 0) {
+    console.log("\n\u26A0\uFE0F  No automatic fixes available. Please address issues manually.\n");
+    return;
+  }
+  if (!options.auto) {
+    console.log("\n" + "\u2500".repeat(50));
+    console.log(`Ready to apply ${actionableFixes.length} fix(es).`);
+    console.log("Run with --auto to apply without confirmation.");
+    console.log("Run with --dry-run to preview changes.\n");
+    const proceed = process.env.SEO_AUTO_APPLY === "true";
+    if (!proceed) {
+      console.log("Set SEO_AUTO_APPLY=true or use --auto flag to apply fixes.\n");
+      return;
+    }
+  }
+  console.log("\n\u{1F527} Applying fixes...");
+  const { applied, skipped } = await (0, import_agent_runtime2.applyFixes)(fixes, { cwd, dryRun: false });
+  console.log("\n" + "\u2550".repeat(50));
+  console.log("RESULTS");
+  console.log("\u2550".repeat(50));
+  if (applied.length > 0) {
+    console.log(`
+\u2705 Applied ${applied.length} fix(es):`);
+    for (const fix of applied) {
+      console.log(`   - ${fix.file}: ${fix.issue.message}`);
+    }
+  }
+  if (skipped.length > 0) {
+    console.log(`
+\u26A0\uFE0F  Skipped ${skipped.length} fix(es):`);
+    for (const fix of skipped) {
+      console.log(`   - ${fix.file}: ${fix.skipReason || "Manual fix required"}`);
+    }
+  }
+  if (config2 && !config2.url) {
+    config2.url = url;
+    (0, import_fs3.writeFileSync)(configPath, JSON.stringify(config2, null, 2));
+    console.log("\n\u{1F4BE} Updated config with URL.");
+  }
+  console.log("\n" + "\u2500".repeat(50));
+  console.log("NEXT STEPS:");
+  console.log("\u2500".repeat(50));
+  console.log("1. Review the changes:");
+  console.log("   git diff");
+  console.log("\n2. Commit the SEO improvements:");
+  console.log('   git add -A && git commit -m "feat(seo): add meta tags and structured data"');
+  console.log("\n3. Re-run the audit to verify:");
+  console.log(`   seo audit --url ${url}`);
+  console.log("");
+}
+
+// src/commands/keywords.ts
+var readline = __toESM(require("readline"));
+var import_agent_runtime3 = require("@rankcli/agent-runtime");
+async function keywords(options) {
+  console.log("\n\u{1F511} SEO Autopilot - Keyword Research\n");
+  console.log("This tool helps you find keywords you can actually rank for,");
+  console.log("based on your site's current authority and competition level.\n");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (question) => {
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        resolve(answer.trim());
+      });
+    });
+  };
+  const askChoice = async (question, choices) => {
+    console.log(`
+${question}`);
+    choices.forEach((choice, i) => {
+      console.log(`  ${i + 1}. ${choice.label}`);
+      console.log(`     ${choice.description}`);
+    });
+    while (true) {
+      const answer = await ask("\nEnter your choice (1-" + choices.length + "): ");
+      const num = parseInt(answer, 10);
+      if (num >= 1 && num <= choices.length) {
+        return choices[num - 1].value;
+      }
+      console.log("Please enter a valid number.");
+    }
+  };
+  try {
+    let url = options.url;
+    if (!url) {
+      url = await ask("Enter your website URL: ");
+    }
+    try {
+      const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
+      url = parsed.href;
+    } catch {
+      console.log("\n\u274C Invalid URL format. Please provide a valid URL.\n");
+      rl.close();
+      return;
+    }
+    const domain = new URL(url).hostname;
+    let seedKeywords = [];
+    if (options.seed) {
+      seedKeywords = options.seed.split(",").map((s) => s.trim());
+    } else if (options.auto) {
+      console.log("\n\u{1F50D} Auto-extracting seed keywords from your page...");
+      seedKeywords = await (0, import_agent_runtime3.extractSeedKeywords)(url);
+      if (seedKeywords.length > 0) {
+        console.log(`Found: ${seedKeywords.join(", ")}`);
+      }
+    }
+    if (seedKeywords.length === 0) {
+      console.log("\n\u{1F4DD} What is your website/product about?");
+      console.log("   (Enter 1-3 main topics or keywords, comma-separated)");
+      const seedInput = await ask("   > ");
+      seedKeywords = seedInput.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      if (seedKeywords.length === 0) {
+        console.log("\n\u274C Please provide at least one seed keyword.\n");
+        rl.close();
+        return;
+      }
+    }
+    console.log("\n\u{1F4CB} Let me ask a few questions to tailor recommendations to your site...\n");
+    const siteProfile = {
+      domain,
+      domainAge: "new",
+      backlinkCount: "none",
+      businessGoal: "signups",
+      contentCapacity: "medium",
+      targetGeo: "us"
+    };
+    for (const q of import_agent_runtime3.SITE_PROFILE_QUESTIONS) {
+      const answer = await askChoice(q.question, q.options);
+      siteProfile[q.id] = answer;
+    }
+    rl.close();
+    console.log("\n" + "\u2500".repeat(60));
+    console.log("Starting keyword research with your profile:");
+    console.log(`  Domain: ${domain}`);
+    console.log(`  Seeds: ${seedKeywords.join(", ")}`);
+    console.log(`  Age: ${siteProfile.domainAge}`);
+    console.log(`  Backlinks: ${siteProfile.backlinkCount}`);
+    console.log(`  Goal: ${siteProfile.businessGoal}`);
+    console.log("\u2500".repeat(60));
+    const researchOptions = {
+      seedKeywords,
+      siteProfile,
+      url,
+      maxKeywords: 100
+    };
+    const result = await (0, import_agent_runtime3.runKeywordResearch)(researchOptions);
+    console.log((0, import_agent_runtime3.formatKeywordReport)(result));
+    const allKeywords = [...result.quickWins, ...result.mediumTerm, ...result.longTerm];
+    if (allKeywords.length > 5) {
+      console.log("\n\u{1F4DA} Grouping keywords by topic...\n");
+      const topicResult = (0, import_agent_runtime3.groupKeywordsByTopic)(allKeywords);
+      console.log((0, import_agent_runtime3.formatTopicReport)(topicResult));
+    }
+    if (result.quickWins.length > 0) {
+      console.log('\n\u{1F4A1} TIP: Run "seo apply --url ' + url + '" to apply keyword optimizations');
+      console.log('\u{1F4A1} TIP: Run "seo keywords --competitor <domain>" to find competitor keyword gaps');
+    }
+  } catch (error) {
+    console.log(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+    rl.close();
+  }
+}
+async function keywordsQuick(url, providedSeeds) {
+  console.log("\n\u{1F680} Quick Keyword Research Mode\n");
+  try {
+    const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
+    url = parsed.href;
+    let seedKeywords = [];
+    if (providedSeeds) {
+      seedKeywords = providedSeeds.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      console.log(`Using provided seeds: ${seedKeywords.join(", ")}
+`);
+    } else {
+      console.log("\u{1F50D} Extracting keywords from your page...");
+      seedKeywords = await (0, import_agent_runtime3.extractSeedKeywords)(url);
+      if (seedKeywords.length === 0) {
+        console.log("\u274C Could not extract keywords. Please use interactive mode.\n");
+        return;
+      }
+      console.log(`Found seeds: ${seedKeywords.join(", ")}
+`);
+    }
+    const siteProfile = {
+      domain: parsed.hostname,
+      domainAge: "new",
+      backlinkCount: "few",
+      businessGoal: "signups",
+      contentCapacity: "medium",
+      targetGeo: "us"
+    };
+    const result = await (0, import_agent_runtime3.runKeywordResearch)({
+      seedKeywords,
+      siteProfile,
+      url,
+      maxKeywords: 50
+    });
+    console.log((0, import_agent_runtime3.formatKeywordReport)(result));
+    const allKeywords = [...result.quickWins, ...result.mediumTerm, ...result.longTerm];
+    if (allKeywords.length > 5) {
+      console.log("\n\u{1F4DA} Grouping keywords by topic...\n");
+      const topicResult = (0, import_agent_runtime3.groupKeywordsByTopic)(allKeywords);
+      console.log((0, import_agent_runtime3.formatTopicReport)(topicResult));
+    }
+  } catch (error) {
+    console.log(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+  }
+}
+var SUPABASE_URL2 = "https://eqzlmjbvrtrglknphdai.supabase.co";
+async function keywordsAI(url, options = {}) {
+  console.log("\n\u{1F916} AI-Powered Keyword Research\n");
+  console.log("This uses GPT-4 to analyze your site and generate keyword recommendations");
+  console.log("with competitive analysis and free tool ideas.\n");
+  const openaiApiKey = options.openaiApiKey || process.env.OPENAI_API_KEY;
+  try {
+    const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
+    url = parsed.href;
+    console.log(`\u{1F4CD} Analyzing: ${url}`);
+    console.log("");
+    if (!options.forceLocal) {
+      console.log("\u{1F517} Connecting to RankCLI cloud...");
+      try {
+        const response = await fetch(`${SUPABASE_URL2}/functions/v1/ai-keywords`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+            // Auth header would go here if user is logged in
+          },
+          body: JSON.stringify({
+            url,
+            mode: "analyze"
+          })
+        });
+        if (response.ok) {
+          const result2 = await response.json();
+          if (result2.tier === "free" && result2.teaser) {
+            console.log("\n" + "\u2500".repeat(60));
+            console.log("\u{1F512} FREE TIER - Limited Preview");
+            console.log("\u2500".repeat(60));
+            console.log(`Found ${result2.teaser.totalKeywordsFound} keywords`);
+            console.log(`Top keywords: ${result2.teaser.topKeywords.join(", ")}`);
+            console.log(`
+${result2.teaser.upgradeMessage}`);
+            console.log('\n\u{1F4A1} Run "rankcli login" to access your paid plan features.\n');
+            return;
+          }
+          displayAIKeywordResults(result2);
+          return;
+        } else {
+          const errorText = await response.text();
+          console.log(`\u26A0\uFE0F  Cloud request failed, running locally...
+`);
+        }
+      } catch (err) {
+        console.log("\u26A0\uFE0F  Cloud unavailable, running locally...\n");
+      }
+    }
+    if (!openaiApiKey) {
+      console.log("\u274C OpenAI API key required for local processing.");
+      console.log('   Set OPENAI_API_KEY environment variable, or use "rankcli login" for cloud processing.\n');
+      return;
+    }
+    console.log("\u{1F52C} Running local AI analysis (this may take a minute)...\n");
+    const result = await (0, import_agent_runtime3.runAIKeywordResearch)({
+      url,
+      tier: "solo",
+      openaiApiKey,
+      enableEnhancedToolIdeas: true,
+      competitiveSearchKeys: {
+        braveApiKey: process.env.BRAVE_API_KEY,
+        serperApiKey: process.env.SERPER_API_KEY,
+        githubToken: process.env.GITHUB_TOKEN
+      }
+    });
+    displayAIKeywordResults(result);
+  } catch (error) {
+    console.log(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+  }
+}
+function displayAIKeywordResults(result) {
+  if (result.siteSummary) {
+    console.log("\u2500".repeat(60));
+    console.log("\u{1F4CB} SITE ANALYSIS");
+    console.log("\u2500".repeat(60));
+    console.log(`Product: ${result.siteSummary.productName || "Unknown"}`);
+    console.log(`Industry: ${result.siteSummary.industry || "Unknown"}`);
+    console.log(`Target: ${result.siteSummary.targetAudience || "Unknown"}`);
+    if (result.siteSummary.tagline) {
+      console.log(`Tagline: ${result.siteSummary.tagline}`);
+    }
+    console.log("");
+  }
+  if (result.uncertainty) {
+    const confidence = Math.round(result.uncertainty.overallConfidence * 100);
+    const emoji = confidence >= 70 ? "\u2705" : confidence >= 50 ? "\u26A0\uFE0F" : "\u274C";
+    console.log(`${emoji} Confidence: ${confidence}%`);
+    if (result.uncertainty.explanation) {
+      console.log(`   ${result.uncertainty.explanation}`);
+    }
+    console.log("");
+  }
+  if (result.recommendations && result.recommendations.length > 0) {
+    console.log("\u2500".repeat(60));
+    console.log("\u{1F3AF} KEYWORD RECOMMENDATIONS");
+    console.log("\u2500".repeat(60));
+    for (const rec of result.recommendations.slice(0, 15)) {
+      const actionEmoji = {
+        "create-page": "\u{1F4C4}",
+        "build-tool": "\u{1F6E0}\uFE0F",
+        "optimize-existing": "\u{1F4C8}",
+        "needs-input": "\u2753",
+        "skip": "\u23ED\uFE0F"
+      }[rec.action] || "\u2022";
+      console.log(`
+${actionEmoji} ${rec.keyword}`);
+      console.log(`   Action: ${rec.action.replace("-", " ")}`);
+      console.log(`   Volume: ${rec.searchVolume || "unknown"} | Difficulty: ${rec.difficulty || "unknown"}`);
+      console.log(`   Impact: ${rec.impact || "unknown"} | Effort: ${rec.effort || "unknown"}`);
+      if (rec.rationale) {
+        console.log(`   ${rec.rationale}`);
+      }
+    }
+    console.log("");
+  }
+  if (result.freeToolIdeas && result.freeToolIdeas.length > 0) {
+    console.log("\u2500".repeat(60));
+    console.log("\u{1F6E0}\uFE0F  FREE TOOL IDEAS (Engineering as Marketing)");
+    console.log("\u2500".repeat(60));
+    for (const tool of result.freeToolIdeas.slice(0, 5)) {
+      console.log(`
+\u{1F4A1} ${tool.toolName || tool.toolName}`);
+      console.log(`   ${tool.description || tool.toolDescription || ""}`);
+      if (tool.inputFormat && tool.outputFormat) {
+        console.log(`   \u{1F4E5} Input: ${tool.inputFormat}`);
+        console.log(`   \u{1F4E4} Output: ${tool.outputFormat}`);
+      }
+      if (tool.productTieIn) {
+        console.log(`   \u{1F517} Tie-in: ${tool.productTieIn}`);
+      }
+      if (tool.competitorAnalysis) {
+        console.log(`   \u{1F3C6} Existing: ${tool.competitorAnalysis.existingTools?.join(", ") || "None found"}`);
+        console.log(`   \u2728 Advantage: ${tool.competitorAnalysis.ourAdvantage || "N/A"}`);
+      }
+      if (tool.implementationHints) {
+        console.log(`   \u23F1\uFE0F  Est. time: ${tool.implementationHints.estimatedHours || "Unknown"} hours`);
+        if (tool.implementationHints.suggestedLibraries?.length > 0) {
+          console.log(`   \u{1F4E6} Libraries: ${tool.implementationHints.suggestedLibraries.join(", ")}`);
+        }
+      }
+      if (tool.feasibilityScore) {
+        const score = typeof tool.feasibilityScore === "object" ? tool.feasibilityScore.overallScore : tool.feasibilityScore;
+        console.log(`   \u{1F4CA} Feasibility: ${score}/5`);
+      }
+      console.log(`   \u{1F3AF} Keyword: ${tool.targetKeyword || tool.keyword}`);
+      console.log(`   \u{1F4C8} Volume: ${tool.searchVolume || "unknown"} | Difficulty: ${tool.difficulty || "unknown"}`);
+    }
+    console.log("");
+  }
+  console.log("\u2500".repeat(60));
+  console.log("\u{1F4A1} NEXT STEPS");
+  console.log("\u2500".repeat(60));
+  console.log("1. Start with quick wins (low difficulty, high impact keywords)");
+  console.log("2. Build 1-2 free tools to capture search traffic");
+  console.log('3. Create content pages targeting "Create Page" keywords');
+  console.log("4. Re-run with --wizard to improve accuracy if needed\n");
+}
+async function keywordsCompetitor(yourUrl, seedKeywords, competitors) {
+  console.log("\n\u{1F50D} Competitor Keyword Gap Analysis (SpyFu Kombat-style)\n");
+  try {
+    const parsed = new URL(yourUrl.startsWith("http") ? yourUrl : `https://${yourUrl}`);
+    const yourDomain = parsed.hostname.replace(/^www\./, "");
+    console.log(`Your domain: ${yourDomain}`);
+    console.log(`Seed keywords: ${seedKeywords.join(", ")}`);
+    if (competitors && competitors.length > 0) {
+      console.log(`Competitors: ${competitors.join(", ")}`);
+    } else {
+      console.log("Competitors: Auto-discovering from SERP...");
+    }
+    console.log("");
+    console.log("Analyzing competitor keywords (this may take a moment)...\n");
+    const result = await (0, import_agent_runtime3.discoverCompetitorKeywords)(
+      yourDomain,
+      seedKeywords,
+      competitors
+    );
+    console.log((0, import_agent_runtime3.formatCompetitorReport)(result));
+    if (result.missingKeywords.length > 0) {
+      console.log("\n\u{1F3AF} ACTION ITEMS:");
+      console.log("\u2500".repeat(60));
+      console.log(`1. Create content targeting these ${Math.min(5, result.missingKeywords.length)} high-priority gaps:`);
+      for (const kw of result.missingKeywords.slice(0, 5)) {
+        console.log(`   \u2022 "${kw.keyword}"`);
+      }
+      console.log("\n2. Optimize existing pages for core keywords your competitors all rank for");
+      console.log("3. Protect your unique keyword advantages with quality content\n");
+    }
+  } catch (error) {
+    console.log(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+  }
+}
+
+// src/commands/content.ts
+var import_agent_runtime4 = require("@rankcli/agent-runtime");
+async function analyzeContent(options) {
+  console.log("\n\u{1F4DD} SEO Autopilot - Content Analysis\n");
+  const mode = options.mode || "full";
+  if (mode === "headline" || options.headline) {
+    const headline = options.headline || "";
+    if (!headline) {
+      console.log('\u274C Please provide a headline with --headline "Your Headline Here"');
+      return;
+    }
+    const analysis = (0, import_agent_runtime4.analyzeHeadline)(headline);
+    console.log((0, import_agent_runtime4.formatHeadlineReport)(analysis));
+    if (options.keyword) {
+      console.log("\n\u{1F4CB} HEADLINE VARIATIONS");
+      console.log("\u2500".repeat(60));
+      const variations = (0, import_agent_runtime4.generateHeadlineVariations)(options.keyword, [options.keyword]);
+      for (const v of variations.slice(0, 5)) {
+        console.log(`  \u2022 ${v}`);
+      }
+      console.log("");
+    }
+    return;
+  }
+  if (options.url) {
+    console.log(`Fetching content from ${options.url}...`);
+    try {
+      const result = await (0, import_agent_runtime4.crawlUrl)(options.url);
+      if (!result.html) {
+        console.log("\u274C Could not fetch content from URL");
+        return;
+      }
+      const title = result.meta?.title || "";
+      const h1 = result.headings?.find((h) => h.level === 1)?.text || "";
+      const headings = result.headings?.map((h) => h.text) || [];
+      const bodyText = extractBodyText(result.html);
+      const paragraphs = bodyText.split(/\n\n+/);
+      console.log(`
+Analyzing: "${title || options.url}"
+`);
+      if (mode === "full" || mode === "readability") {
+        const readability = (0, import_agent_runtime4.analyzeReadability)(bodyText);
+        console.log((0, import_agent_runtime4.formatReadabilityReport)(readability));
+      }
+      if (mode === "full" && title) {
+        const headlineAnalysis = (0, import_agent_runtime4.analyzeHeadline)(title);
+        console.log((0, import_agent_runtime4.formatHeadlineReport)(headlineAnalysis));
+      }
+      if (options.keyword && (mode === "full" || mode === "density")) {
+        const densityAnalysis = (0, import_agent_runtime4.analyzeKeywordDensity)(options.keyword, {
+          title,
+          h1,
+          headings,
+          body: bodyText,
+          firstParagraph: paragraphs[0],
+          lastParagraph: paragraphs[paragraphs.length - 1]
+        });
+        console.log((0, import_agent_runtime4.formatKeywordDensityReport)(densityAnalysis));
+      }
+      if (options.keyword && (mode === "full" || mode === "snippet")) {
+        const snippetAnalysis = (0, import_agent_runtime4.analyzeFeaturedSnippetPotential)(
+          options.keyword,
+          bodyText,
+          headings
+        );
+        console.log((0, import_agent_runtime4.formatFeaturedSnippetReport)(snippetAnalysis));
+      }
+      if (options.keyword) {
+        const intentAnalysis = (0, import_agent_runtime4.classifyIntent)(options.keyword);
+        console.log((0, import_agent_runtime4.formatIntentReport)(options.keyword, intentAnalysis));
+      }
+      console.log("\n\u{1F4CA} CONTENT SUMMARY");
+      console.log("\u2500".repeat(60));
+      console.log(`  Title:      ${title || "(none)"}`);
+      console.log(`  H1:         ${h1 || "(none)"}`);
+      console.log(`  Word Count: ${bodyText.split(/\s+/).length}`);
+      console.log(`  Headings:   ${headings.length}`);
+      console.log("");
+    } catch (error) {
+      console.log(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+    }
+  } else {
+    console.log("Usage:");
+    console.log("  seo content -u <url>                    Full content analysis");
+    console.log('  seo content -u <url> -k "keyword"       Analyze with target keyword');
+    console.log('  seo content --headline "Your Title"     Analyze headline only');
+    console.log("  seo content -u <url> --mode readability Readability only");
+    console.log('  seo content -u <url> -k "kw" --mode density   Keyword density only');
+    console.log('  seo content -u <url> -k "kw" --mode snippet   Featured snippet analysis');
+    console.log("");
+  }
+}
+async function analyzeIntent(keyword) {
+  console.log("\n\u{1F50D} Search Intent Analysis\n");
+  const analysis = (0, import_agent_runtime4.classifyIntent)(keyword);
+  console.log((0, import_agent_runtime4.formatIntentReport)(keyword, analysis));
+}
+function extractBodyText(html) {
+  let text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<[^>]+>/g, " ");
+  text = text.replace(/&nbsp;/g, " ");
+  text = text.replace(/&amp;/g, "&");
+  text = text.replace(/&lt;/g, "<");
+  text = text.replace(/&gt;/g, ">");
+  text = text.replace(/&quot;/g, '"');
+  text = text.replace(/\s+/g, " ").trim();
+  return text;
+}
+
+// src/commands/setup.ts
+var readline2 = __toESM(require("readline"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_agent_runtime5 = require("@rankcli/agent-runtime");
+async function setup(options) {
+  console.log("\n\u{1F527} SEO Autopilot - Setup\n");
+  const projectPath = process.cwd();
+  if (!fs.existsSync(path.join(projectPath, "package.json")) && !fs.existsSync(path.join(projectPath, "index.html"))) {
+    console.log("\u26A0\uFE0F  No package.json or index.html found. Are you in a web project directory?\n");
+  }
+  if (options.all || !options.ga4 && !options.gsc && !options.githubAction) {
+    await interactiveSetup(projectPath);
+    return;
+  }
+  if (options.ga4) {
+    await setupGA4(projectPath, options.ga4);
+  }
+  if (options.gsc) {
+    await setupGSC(projectPath, options.gsc);
+  }
+  if (options.githubAction) {
+    await setupGitHubAction(projectPath, options.schedule || "weekly");
+  }
+}
+async function interactiveSetup(projectPath) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (question) => {
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        resolve(answer.trim());
+      });
+    });
+  };
+  try {
+    console.log("This wizard will help you set up SEO tracking for your project.\n");
+    console.log("\u2500".repeat(60));
+    console.log("\u{1F4CA} STEP 1: Google Analytics 4\n");
+    console.log("GA4 tracks visitor behavior on your site.");
+    console.log("Get your Measurement ID from: https://analytics.google.com");
+    console.log("Go to: Admin > Data Streams > Your Stream > Measurement ID\n");
+    const ga4Id = await ask("Enter GA4 Measurement ID (G-XXXXXXXXXX) or press Enter to skip: ");
+    if (ga4Id && ga4Id.startsWith("G-")) {
+      await setupGA4(projectPath, ga4Id);
+    } else if (ga4Id) {
+      console.log('\u26A0\uFE0F  Invalid format. GA4 IDs start with "G-". Skipping.\n');
+    } else {
+      console.log("Skipping GA4 setup.\n");
+    }
+    console.log("\u2500".repeat(60));
+    console.log("\u{1F50D} STEP 2: Google Search Console\n");
+    console.log("GSC shows how Google sees your site and what queries you rank for.");
+    console.log("Get your verification code from: https://search.google.com/search-console");
+    console.log("Go to: Settings > Ownership verification > HTML tag\n");
+    const gscCode = await ask("Enter GSC verification code or press Enter to skip: ");
+    if (gscCode && gscCode.length > 10) {
+      await setupGSC(projectPath, gscCode);
+    } else if (gscCode) {
+      console.log("\u26A0\uFE0F  Code seems too short. Skipping.\n");
+    } else {
+      console.log("Skipping GSC verification.\n");
+    }
+    console.log("\u2500".repeat(60));
+    console.log("\u{1F916} STEP 3: Automated SEO Monitoring\n");
+    console.log("A GitHub Action can automatically check your site's SEO on a schedule.");
+    console.log("It creates issues with reports and can auto-fix some problems.\n");
+    const setupAction = await ask("Set up GitHub Action? (y/n): ");
+    if (setupAction.toLowerCase() === "y" || setupAction.toLowerCase() === "yes") {
+      console.log("\nHow often should the check run?");
+      console.log("  1. Weekly (recommended for most sites)");
+      console.log("  2. Daily (for high-traffic sites)");
+      console.log("  3. Monthly (for low-traffic sites)\n");
+      const scheduleChoice = await ask("Enter choice (1-3): ");
+      const scheduleMap = {
+        "1": "weekly",
+        "2": "daily",
+        "3": "monthly"
+      };
+      const schedule = scheduleMap[scheduleChoice] || "weekly";
+      const siteUrl = await ask("Enter your site URL (https://example.com): ");
+      if (siteUrl) {
+        await setupGitHubAction(projectPath, schedule, siteUrl);
+      }
+    } else {
+      console.log("Skipping GitHub Action setup.\n");
+    }
+    console.log("\u2500".repeat(60));
+    console.log("\u2705 Setup complete!\n");
+    console.log("Next steps:");
+    console.log("  1. Commit the changes to your repository");
+    console.log("  2. If using GitHub Actions, add required secrets (see .github/SEO_SETUP.md)");
+    console.log("  3. Deploy your site to apply tracking code changes");
+    console.log("  4. Verify GSC ownership and GA4 data collection\n");
+    rl.close();
+  } catch (error) {
+    console.log(`
+\u274C Error: ${error instanceof Error ? error.message : "Unknown error"}
+`);
+    rl.close();
+  }
+}
+async function setupGA4(projectPath, measurementId) {
+  console.log(`Setting up Google Analytics 4 (${measurementId})...`);
+  const result = await (0, import_agent_runtime5.injectGA4)(projectPath, { measurementId });
+  if (result.success) {
+    console.log(`\u2705 ${result.message}`);
+    if (result.file) {
+      console.log(`   Modified: ${result.file}`);
+    }
+  } else {
+    console.log(`\u26A0\uFE0F  ${result.message}`);
+    if (result.code) {
+      console.log("\nManually add this code to your HTML <head>:\n");
+      console.log(result.code);
+    }
+  }
+  const envExamplePath = path.join(projectPath, ".env.example");
+  const envContent = (0, import_agent_runtime5.generateGA4EnvTemplate)();
+  if (fs.existsSync(envExamplePath)) {
+    const existing = fs.readFileSync(envExamplePath, "utf-8");
+    if (!existing.includes("GA4_MEASUREMENT_ID")) {
+      fs.appendFileSync(envExamplePath, "\n" + envContent);
+      console.log("   Updated: .env.example");
+    }
+  } else {
+    fs.writeFileSync(envExamplePath, envContent);
+    console.log("   Created: .env.example");
+  }
+  console.log("");
+}
+async function setupGSC(projectPath, verificationCode) {
+  console.log("Setting up Google Search Console verification...");
+  const result = await (0, import_agent_runtime5.injectGSCVerification)(projectPath, verificationCode);
+  if (result.success) {
+    console.log(`\u2705 ${result.message}`);
+    if (result.file) {
+      console.log(`   Modified: ${result.file}`);
+    }
+  } else {
+    console.log(`\u26A0\uFE0F  ${result.message}`);
+  }
+  console.log("");
+}
+async function setupGitHubAction(projectPath, schedule, siteUrl) {
+  console.log(`Setting up GitHub Action (${schedule} schedule)...`);
+  const config2 = {
+    schedule,
+    siteUrl: siteUrl || "https://example.com",
+    features: {
+      audit: true,
+      tracking: true,
+      autoFix: true,
+      createIssues: true,
+      createPRs: true
+    }
+  };
+  const { files, instructions } = (0, import_agent_runtime5.writeGitHubActionFiles)(projectPath, config2);
+  console.log("\u2705 GitHub Action files created:");
+  for (const file of files) {
+    console.log(`   - ${path.relative(projectPath, file)}`);
+  }
+  console.log(instructions);
+}
+function showGSCInstructions() {
+  console.log((0, import_agent_runtime5.getGSCSetupInstructions)());
+}
+
+// src/commands/auth.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+var import_inquirer = __toESM(require("inquirer"));
+var import_open = __toESM(require("open"));
+async function login(options) {
+  if (isLoggedIn()) {
+    const { email } = getUserInfo();
+    console.log(import_chalk2.default.yellow(`Already logged in as ${email}`));
+    console.log(import_chalk2.default.dim('Run "rankcli logout" to sign out first.'));
+    return;
+  }
+  const spinner = (0, import_ora2.default)();
+  try {
+    if (options.token) {
+      const apiKey = options.token;
+      if (!apiKey.startsWith("rankcli_")) {
+        console.log(import_chalk2.default.red('Invalid API key format. Keys should start with "rankcli_"'));
+        return;
+      }
+      spinner.start("Validating API key...");
+      const result = await validateApiKey(apiKey);
+      if (!result.valid) {
+        spinner.fail("Invalid API key");
+        console.log(import_chalk2.default.red(`
+${result.error}`));
+        return;
+      }
+      saveApiKey(apiKey);
+      if (result.subscription) {
+        saveSubscription({
+          planId: result.subscription.planId,
+          planName: result.subscription.planName,
+          sitesLimit: result.subscription.sitesLimit
+        });
+      }
+      spinner.succeed(`Authenticated via API key`);
+      console.log(import_chalk2.default.dim(`
+Email: ${result.user?.email}`));
+      console.log(import_chalk2.default.dim(`Plan: ${result.subscription?.planName || "Free"}`));
+      return;
+    }
+    if (options.browser) {
+      console.log(import_chalk2.default.cyan("\nOpening browser for login..."));
+      console.log(import_chalk2.default.dim("Complete the login in your browser, then return here.\n"));
+      const loginUrl = `${WEB_APP_URL}/login?cli=true`;
+      await (0, import_open.default)(loginUrl);
+      const { token } = await import_inquirer.default.prompt([
+        {
+          type: "password",
+          name: "token",
+          message: "Paste your CLI token from the browser:",
+          mask: "*"
+        }
+      ]);
+      spinner.start("Verifying token...");
+      const supabase = getSupabaseClient();
+      const { data, error } = await supabase.auth.getUser(token);
+      if (error || !data.user) {
+        spinner.fail("Invalid token");
+        console.log(import_chalk2.default.red("The token is invalid or expired. Please try again."));
+        return;
+      }
+      const { data: sessionData, error: sessionError } = await supabase.auth.setSession({
+        access_token: token,
+        refresh_token: ""
+        // Will need to handle this differently
+      });
+      if (sessionError || !sessionData.session) {
+        spinner.fail("Failed to establish session");
+        return;
+      }
+      saveSession(sessionData.session);
+      await fetchAndSaveSubscription();
+      spinner.succeed(`Logged in as ${import_chalk2.default.green(data.user.email)}`);
+    } else {
+      let email = options.email;
+      if (!email) {
+        const answers = await import_inquirer.default.prompt([
+          {
+            type: "input",
+            name: "email",
+            message: "Email:",
+            validate: (input) => {
+              if (!input.includes("@")) return "Please enter a valid email";
+              return true;
+            }
+          }
+        ]);
+        email = answers.email;
+      }
+      const { password } = await import_inquirer.default.prompt([
+        {
+          type: "password",
+          name: "password",
+          message: "Password:",
+          mask: "*"
+        }
+      ]);
+      spinner.start("Signing in...");
+      const supabase = getSupabaseClient();
+      const { data, error } = await supabase.auth.signInWithPassword({
+        email,
+        password
+      });
+      if (error) {
+        spinner.fail("Login failed");
+        console.log(import_chalk2.default.red(`
+${error.message}`));
+        if (error.message.includes("Invalid login")) {
+          console.log(import_chalk2.default.dim("\nDon't have an account? Sign up at:"));
+          console.log(import_chalk2.default.cyan(`  ${WEB_APP_URL}/signup`));
+        }
+        return;
+      }
+      if (!data.session) {
+        spinner.fail("No session returned");
+        return;
+      }
+      saveSession(data.session);
+      await fetchAndSaveSubscription();
+      spinner.succeed(`Logged in as ${import_chalk2.default.green(data.user?.email)}`);
+      const { planName, sitesLimit } = getUserInfo();
+      console.log(import_chalk2.default.dim(`
+Plan: ${planName} (${sitesLimit} site${sitesLimit !== 1 ? "s" : ""})`));
+    }
+  } catch (err) {
+    spinner.fail("Login failed");
+    console.error(import_chalk2.default.red(err instanceof Error ? err.message : "Unknown error"));
+  }
+}
+async function logout() {
+  if (!isLoggedIn()) {
+    console.log(import_chalk2.default.yellow("Not logged in"));
+    return;
+  }
+  const { email } = getUserInfo();
+  const spinner = (0, import_ora2.default)("Signing out...").start();
+  try {
+    const supabase = getSupabaseClient();
+    await supabase.auth.signOut();
+    clearCredentials();
+    spinner.succeed(`Logged out from ${import_chalk2.default.dim(email)}`);
+  } catch (err) {
+    spinner.fail("Logout failed");
+    console.error(import_chalk2.default.red(err instanceof Error ? err.message : "Unknown error"));
+  }
+}
+async function whoami() {
+  if (!isLoggedIn()) {
+    console.log(import_chalk2.default.yellow("Not logged in"));
+    console.log(import_chalk2.default.dim('\nRun "rankcli login" to sign in.'));
+    console.log(import_chalk2.default.dim(`Or sign up at: ${WEB_APP_URL}/signup`));
+    return;
+  }
+  const spinner = (0, import_ora2.default)("Checking account...").start();
+  try {
+    if (isApiKeyAuth()) {
+      const apiKey = getApiKey();
+      if (apiKey) {
+        const result = await validateApiKey(apiKey);
+        if (result.valid && result.subscription) {
+          saveSubscription({
+            planId: result.subscription.planId,
+            planName: result.subscription.planName,
+            sitesLimit: result.subscription.sitesLimit
+          });
+        }
+      }
+    } else {
+      await fetchAndSaveSubscription();
+    }
+    const { email, planName, sitesLimit } = getUserInfo();
+    const authMethod = isApiKeyAuth() ? "API Key" : "Session";
+    spinner.stop();
+    console.log(import_chalk2.default.bold("\nRankCLI Account"));
+    console.log("\u2500".repeat(40));
+    console.log(`  Email:  ${import_chalk2.default.cyan(email || "N/A")}`);
+    console.log(`  Plan:   ${import_chalk2.default.green(planName)}`);
+    console.log(`  Sites:  ${sitesLimit} allowed`);
+    console.log(`  Auth:   ${import_chalk2.default.dim(authMethod)}`);
+    console.log("\u2500".repeat(40));
+    console.log(import_chalk2.default.dim(`
+Manage at: ${WEB_APP_URL}/account`));
+  } catch (err) {
+    spinner.fail("Failed to fetch account info");
+    console.error(import_chalk2.default.red(err instanceof Error ? err.message : "Unknown error"));
+  }
+}
+async function fetchAndSaveSubscription() {
+  const supabase = await getAuthenticatedClient();
+  if (!supabase) return;
+  const { userId } = getUserInfo();
+  if (!userId) return;
+  const { data: subscription } = await supabase.from("user_subscriptions").select(`
+      plan:subscription_plans (
+        plan_id,
+        name,
+        sites_limit
+      )
+    `).eq("user_id", userId).single();
+  if (subscription?.plan) {
+    const plan = subscription.plan;
+    saveSubscription({
+      planId: plan.plan_id,
+      planName: plan.name,
+      sitesLimit: plan.sites_limit
+    });
+  } else {
+    saveSubscription({
+      planId: void 0,
+      planName: "Free",
+      sitesLimit: 1
+    });
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("rankcli").description("RankCLI - Ship code, get ranked. SEO meets CI/CD.").version("0.0.1");
+program.command("login").description("Log in to your RankCLI account").option("-e, --email <email>", "Email address").option("-b, --browser", "Open browser for login").option("-t, --token <apiKey>", "API key for non-interactive authentication").action(login);
+program.command("logout").description("Log out of your RankCLI account").action(logout);
+program.command("whoami").description("Show current logged in user").action(whoami);
+program.command("init").description("Initialize SEO Autopilot in your project").option("-y, --yes", "Skip prompts and use defaults").action(init);
+program.command("analyze").description("AI analyzes your codebase for SEO opportunities").option("-v, --verbose", "Show detailed output").action(analyze);
+program.command("audit").description("Run a comprehensive SEO audit (170+ checks, Ahrefs-level)").option("-u, --url <url>", "URL to audit").option("-o, --output <format>", "Output format (json, console)", "console").option("--check-links", "Check for broken internal/external links (slower)").option("--max-pages <n>", "Max pages to crawl (default: 5)").option("--ai", "Enable AI analysis").option("--ai-provider <provider>", "AI provider: openai or anthropic").option("--ai-key <key>", "API key (or set OPENAI_API_KEY/ANTHROPIC_API_KEY)").action(audit);
+program.command("apply").description("Analyze a live URL and apply SEO fixes to your codebase").option("-u, --url <url>", "URL to analyze").option("--auto", "Auto-apply fixes without confirmation").option("--dry-run", "Preview changes without applying").action(apply);
+program.command("keywords").description("AI-powered keyword research with actionable suggestions").option("-u, --url <url>", "Your website URL").option("-s, --seed <keywords>", "Seed keywords (comma-separated)").option("--auto", "Auto-extract seed keywords from your page").option("--quick", "Quick mode - skip questions, use defaults").option("--ai", "Use GPT-4 for enhanced analysis with free tool ideas").option("--local", "Force local processing (skip cloud worker)").option("--competitor", "Competitor gap analysis mode (SpyFu Kombat-style)").option("-c, --competitors <domains>", "Competitor domains (comma-separated)").action(async (options) => {
+  if (options.ai && options.url) {
+    await keywordsAI(options.url, {
+      forceLocal: options.local,
+      openaiApiKey: process.env.OPENAI_API_KEY
+    });
+  } else if (options.competitor && options.url && options.seed) {
+    const seeds = options.seed.split(",").map((s) => s.trim());
+    const competitors = options.competitors ? options.competitors.split(",").map((s) => s.trim()) : void 0;
+    await keywordsCompetitor(options.url, seeds, competitors);
+  } else if (options.quick && options.url) {
+    await keywordsQuick(options.url, options.seed);
+  } else {
+    await keywords(options);
+  }
+});
+program.command("content").description("Analyze content for readability, keyword density, and featured snippets").option("-u, --url <url>", "URL to analyze").option("-k, --keyword <keyword>", "Target keyword for analysis").option("--headline <headline>", "Analyze a headline").option("--mode <mode>", "Analysis mode (full, readability, headline, snippet, density)", "full").action(analyzeContent);
+program.command("intent").description("Classify search intent for a keyword").argument("<keyword>", "Keyword to analyze").action(analyzeIntent);
+program.command("competitors").description("Analyze competitor SEO strategies").option("-d, --domain <domain>", "Competitor domain to analyze").action(() => {
+  console.log("Competitor analysis coming soon...");
+});
+program.command("rank").description("Check current keyword rankings").action(() => {
+  console.log("Rank tracking coming soon...");
+});
+program.command("report").description("Generate SEO performance report").option("-f, --format <format>", "Report format (pdf, html, json)", "html").action(() => {
+  console.log("Report generation coming soon...");
+});
+program.command("watch").description("Continuous monitoring mode").action(() => {
+  console.log("Watch mode coming soon...");
+});
+program.command("setup").description("Set up SEO tracking (GA4, Search Console, GitHub Actions)").option("--ga4 <id>", "Google Analytics 4 Measurement ID (G-XXXXXXXXXX)").option("--gsc <code>", "Google Search Console verification code").option("--github-action", "Set up automated GitHub Action").option("--schedule <freq>", "GitHub Action schedule (daily, weekly, monthly)", "weekly").option("--all", "Interactive setup wizard").action(setup);
+program.command("gsc-setup").description("Show Google Search Console API setup instructions").action(showGSCInstructions);
+program.parse();