cc-codeconductor 0.2.8 → 0.2.9

package/dist/index.js

@@ -7044,7 +7044,7 @@ function getExitCode(error) {
 // package.json
 var package_default = {
   name: "cc-codeconductor",
-  version: "0.2.8",
+  version: "0.2.9",
   description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
   keywords: [
     "ai",
@@ -12770,6 +12770,16 @@ import { homedir as homedir4 } from "node:os";
 import { resolve as resolve8 } from "node:path";
 
 // src/core/lsp/lsp-config-utils.ts
+function getLanguageServerConfig(lspIds) {
+  const languageServers = {};
+  for (const lspId of lspIds) {
+    const config = getLspCommand(lspId);
+    if (config) {
+      languageServers[lspId] = { command: config.command, args: [...config.args] };
+    }
+  }
+  return languageServers;
+}
 function getLspCommand(lspId) {
   switch (lspId) {
     case "typescript":
@@ -12777,7 +12787,7 @@ function getLspCommand(lspId) {
     case "php":
       return { command: "intelephense", args: ["--stdio"] };
     case "python":
-      return { command: "pylsp", args: [] };
+      return { command: "pyright-langserver", args: ["--stdio"] };
     case "kotlin":
       return { command: "kotlin-language-server", args: [] };
     default:
@@ -12836,19 +12846,11 @@ class ClaudeLspGenerator {
     if (successfulLsps.length === 0) {
       return [];
     }
-    const mcpServers = {};
-    for (const lsp of successfulLsps) {
-      const config = getLspCommand(lsp.lspId);
-      if (config) {
-        mcpServers[lsp.lspId] = { command: config.command, args: [...config.args] };
-      }
-    }
-    const content = JSON.stringify({
-      mcpServers
-    }, null, 2);
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp) => lsp.lspId));
+    const content = JSON.stringify(languageServers, null, 2);
     return [
       {
-        path: ".claude/settings.json",
+        path: ".claude/plugins/codeconductor-lsp/.lsp.json",
         content,
         overwrite: false
       }
@@ -12863,8 +12865,6 @@ function createClaudeLspGenerator() {
 }
 
 // src/adapters/codex/codex-lsp-generator.ts
-var MCP_STARTUP_TIMEOUT_SEC = 120;
-
 class CodexLspGenerator {
   name = "codex-lsp";
   target = "codex";
@@ -12877,12 +12877,11 @@ class CodexLspGenerator {
     for (const lsp of successfulLsps) {
       const config = getLspCommand(lsp.lspId);
       if (config) {
-        sections.push(`[mcp_servers.${lsp.lspId}]`);
+        sections.push(`[language_servers.${lsp.lspId}]`);
         sections.push(`command = "${config.command}"`);
         if (config.args.length > 0) {
           sections.push(`args = [${config.args.map((a) => `"${a}"`).join(", ")}]`);
         }
-        sections.push(`startup_timeout_sec = ${MCP_STARTUP_TIMEOUT_SEC}`);
         sections.push("");
       }
     }
@@ -12912,19 +12911,13 @@ class CursorLspGenerator {
     if (successfulLsps.length === 0) {
       return [];
     }
-    const mcpServers = {};
-    for (const lsp of successfulLsps) {
-      const config = getLspCommand(lsp.lspId);
-      if (config) {
-        mcpServers[lsp.lspId] = { command: config.command, args: [...config.args] };
-      }
-    }
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp) => lsp.lspId));
     const content = JSON.stringify({
-      mcpServers
+      languageServers
     }, null, 2);
     return [
       {
-        path: ".cursor/mcp.json",
+        path: ".cursor/settings.json",
         content,
         overwrite: false
       }
@@ -12947,15 +12940,9 @@ class GeminiLspGenerator {
     if (successfulLsps.length === 0) {
       return [];
     }
-    const mcpServers = {};
-    for (const lsp of successfulLsps) {
-      const config = getLspCommand(lsp.lspId);
-      if (config) {
-        mcpServers[lsp.lspId] = { command: config.command, args: [...config.args] };
-      }
-    }
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp) => lsp.lspId));
     const content = JSON.stringify({
-      mcpServers
+      languageServers
     }, null, 2);
     return [
       {
@@ -12974,38 +12961,45 @@ function createGeminiLspGenerator() {
 }
 
 // src/adapters/opencode/opencode-lsp-generator.ts
+var OPENCODE_LSP_EXTENSIONS = {
+  typescript: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+  php: [".php"],
+  python: [".py", ".pyi"],
+  kotlin: [".kt", ".kts"]
+};
+
 class OpenCodeLspGenerator {
   name = "opencode-lsp";
   target = "opencode";
   generate(installedLsps) {
-    const successfulLsps = installedLsps.filter((lsp) => lsp.status !== "failed");
+    const successfulLsps = installedLsps.filter((lsp2) => lsp2.status !== "failed");
     if (successfulLsps.length === 0) {
       return [];
     }
-    const mcp = {};
-    for (const lsp of successfulLsps) {
-      const config = getLspCommand(lsp.lspId);
-      if (config) {
-        mcp[lsp.lspId] = {
-          type: "local",
-          command: [config.command, ...config.args],
-          enabled: true,
-          timeout: 120000
-        };
-      }
-    }
+    const languageServers = getLanguageServerConfig(successfulLsps.map((lsp2) => lsp2.lspId));
+    const lsp = this.toOpenCodeLspConfig(languageServers);
     const content = JSON.stringify({
       $schema: "https://opencode.ai/config.json",
-      mcp
+      lsp
     }, null, 2);
     return [
       {
         path: ".opencode/opencode.json",
-        content,
+        content: `${content}
+`,
         overwrite: false
       }
     ];
   }
+  toOpenCodeLspConfig(languageServers) {
+    return Object.fromEntries(Object.entries(languageServers).map(([name, config]) => [
+      name,
+      {
+        command: [config.command, ...config.args],
+        extensions: OPENCODE_LSP_EXTENSIONS[name] ?? []
+      }
+    ]));
+  }
   async isAvailable() {
     return true;
   }
@@ -13201,13 +13195,13 @@ var LSP_DEFINITIONS = [
   {
     id: "python",
     language: "python",
-    serverName: "Python LSP Server",
-    packageManager: "pip",
-    package: "python-lsp-server",
-    binaryName: "pylsp",
-    installCmd: "pip install --user python-lsp-server",
+    serverName: "Pyright",
+    packageManager: "npm",
+    package: "pyright",
+    binaryName: "pyright-langserver",
+    installCmd: "npm install -g pyright",
     versionFlag: "--version",
-    pipDetect: "python-lsp-server"
+    npmDetect: "pyright"
   },
   {
     id: "kotlin",
@@ -13397,6 +13391,1505 @@ function getLspConfigGenerator(target) {
   }
 }
 
+// src/commands/seo-audit.command.ts
+import { writeFile as writeFile5, mkdir as mkdir6 } from "node:fs/promises";
+import { dirname as dirname4, resolve as resolve9 } from "node:path";
+
+// src/infrastructure/http/safe-fetch.ts
+import { lookup } from "node:dns/promises";
+var PRIVATE_IP_RANGES = [
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^127\./,
+  /^0\./,
+  /^169\.254\./,
+  /^::1$/,
+  /^fc00:/i,
+  /^fe80:/i
+];
+function isPrivateIp(ip) {
+  return PRIVATE_IP_RANGES.some((range) => range.test(ip));
+}
+async function validateUrl(urlString) {
+  let parsed;
+  try {
+    parsed = new URL(urlString);
+  } catch {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Blocked scheme: ${parsed.protocol}. Only http and https are allowed.`);
+  }
+  const hostname = parsed.hostname;
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) {
+    throw new Error(`Blocked hostname: ${hostname}`);
+  }
+  try {
+    const addresses = await lookup(hostname, { all: true });
+    const addrList = Array.isArray(addresses) ? addresses : [addresses];
+    for (const addr of addrList) {
+      if (isPrivateIp(addr.address)) {
+        throw new Error(`SSRF blocked: ${hostname} resolves to private IP ${addr.address}`);
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("SSRF blocked")) {
+      throw error;
+    }
+    throw new Error(`DNS resolution failed for ${hostname}: ${String(error)}`);
+  }
+}
+async function safeFetch(urlString, options = {}) {
+  const { timeout = 1e4, followRedirects = false } = options;
+  await validateUrl(urlString);
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  const start = Date.now();
+  try {
+    const response = await fetch(urlString, {
+      method: "GET",
+      signal: controller.signal,
+      redirect: followRedirects ? "follow" : "manual",
+      headers: {
+        "User-Agent": "CodeConductor-SEO/0.3.0",
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+      }
+    });
+    const responseTime = Date.now() - start;
+    const body = await response.text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      headers,
+      body,
+      responseTime,
+      url: urlString
+    };
+  } catch (error) {
+    const responseTime = Date.now() - start;
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeout}ms: ${urlString}`);
+    }
+    throw new Error(`Fetch failed (${responseTime}ms): ${urlString} — ${String(error)}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function delay(ms) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+
+// src/infrastructure/parsers/sitemap-parser.ts
+function extractTag(xml, tag) {
+  const match = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i"));
+  return match ? match[1].trim() : undefined;
+}
+function extractAllBlocks(xml, tag) {
+  const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "gi");
+  const blocks = [];
+  let match;
+  while ((match = regex.exec(xml)) !== null) {
+    blocks.push(match[1]);
+  }
+  return blocks;
+}
+function parseUrlEntries(xml) {
+  const urlBlocks = extractAllBlocks(xml, "url");
+  return urlBlocks.map((block) => ({
+    url: extractTag(block, "loc") ?? "",
+    lastmod: extractTag(block, "lastmod"),
+    changefreq: extractTag(block, "changefreq"),
+    priority: extractTag(block, "priority")
+  })).filter((entry) => entry.url.length > 0);
+}
+function parseSitemapLocs(xml) {
+  const sitemapBlocks = extractAllBlocks(xml, "sitemap");
+  return sitemapBlocks.map((block) => extractTag(block, "loc")).filter((loc) => loc !== undefined && loc.length > 0);
+}
+function getDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function deduplicateEntries(entries) {
+  const seen = new Set;
+  return entries.filter((entry) => {
+    if (seen.has(entry.url))
+      return false;
+    seen.add(entry.url);
+    return true;
+  });
+}
+function filterSameDomain(entries, domain) {
+  return entries.filter((entry) => {
+    try {
+      return new URL(entry.url).hostname === domain;
+    } catch {
+      return false;
+    }
+  });
+}
+async function parseSitemap(sitemapUrl, options = {}) {
+  const { maxDepth = 2, delay: requestDelay = 0 } = options;
+  return parseSitemapRecursive(sitemapUrl, 0, maxDepth, requestDelay);
+}
+async function parseSitemapRecursive(sitemapUrl, depth, maxDepth, requestDelay) {
+  const response = await safeFetch(sitemapUrl);
+  const xml = response.body;
+  const domain = getDomain(sitemapUrl);
+  const isIndex = /<sitemapindex[\s>]/i.test(xml);
+  if (isIndex) {
+    const childUrls = parseSitemapLocs(xml);
+    if (depth >= maxDepth) {
+      return {
+        entries: [],
+        type: "sitemapindex",
+        childSitemaps: childUrls
+      };
+    }
+    const allEntries = [];
+    const allChildSitemaps = [...childUrls];
+    for (let i = 0;i < childUrls.length; i++) {
+      if (i > 0 && requestDelay > 0) {
+        await delay(requestDelay);
+      }
+      try {
+        const childResult = await parseSitemapRecursive(childUrls[i], depth + 1, maxDepth, requestDelay);
+        allEntries.push(...childResult.entries);
+        allChildSitemaps.push(...childResult.childSitemaps);
+      } catch {}
+    }
+    const deduped2 = deduplicateEntries(allEntries);
+    const filtered2 = domain ? filterSameDomain(deduped2, domain) : deduped2;
+    return {
+      entries: filtered2,
+      type: "sitemapindex",
+      childSitemaps: allChildSitemaps
+    };
+  }
+  const entries = parseUrlEntries(xml);
+  const deduped = deduplicateEntries(entries);
+  const filtered = domain ? filterSameDomain(deduped, domain) : deduped;
+  return {
+    entries: filtered,
+    type: "urlset",
+    childSitemaps: []
+  };
+}
+
+// src/domain/seo/meta-validator.ts
+function extractMetaContent(html, name) {
+  const patterns = [
+    new RegExp(`<meta[^>]*name=["']${name}["'][^>]*content=["']([^"']*)["']`, "i"),
+    new RegExp(`<meta[^>]*content=["']([^"']*)["'][^>]*name=["']${name}["']`, "i")
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match)
+      return match[1].trim();
+  }
+  return;
+}
+function extractPropertyContent(html, property) {
+  const patterns = [
+    new RegExp(`<meta[^>]*property=["']${property}["'][^>]*content=["']([^"']*)["']`, "i"),
+    new RegExp(`<meta[^>]*content=["']([^"']*)["'][^>]*property=["']${property}["']`, "i")
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match)
+      return match[1].trim();
+  }
+  return;
+}
+function extractTitle(html) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? match[1].trim() : undefined;
+}
+function extractCanonical(html) {
+  const match = html.match(/<link[^>]*rel=["']canonical["'][^>]*href=["']([^"']*)["']/i);
+  return match ? match[1].trim() : undefined;
+}
+function extractH1Tags(html) {
+  const regex = /<h1[^>]*>([\s\S]*?)<\/h1>/gi;
+  const results = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    results.push(match[1].trim());
+  }
+  return results;
+}
+function extractHeadingHierarchy(html) {
+  const regex = /<(h[1-6])[^>]*>([\s\S]*?)<\/\1>/gi;
+  const results = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    results.push({ tag: match[1].toLowerCase(), text: match[2].trim() });
+  }
+  return results;
+}
+function extractImgWithoutAlt(html) {
+  const imgRegex = /<img[^>]*>/gi;
+  let count = 0;
+  let match;
+  while ((match = imgRegex.exec(html)) !== null) {
+    if (!/alt=["'][^"']+["']/i.test(match[0])) {
+      count++;
+    }
+  }
+  return count;
+}
+function extractHtmlLang(html) {
+  const match = html.match(/<html[^>]*lang=["']([^"']*)["']/i);
+  return match ? match[1].trim() : undefined;
+}
+function extractViewport(html) {
+  return extractMetaContent(html, "viewport");
+}
+function extractInternalLinks(html, baseUrl) {
+  let domain;
+  try {
+    domain = new URL(baseUrl).hostname;
+  } catch {
+    return 0;
+  }
+  const linkRegex = /href=["']([^"']*)["']/gi;
+  let count = 0;
+  let match;
+  while ((match = linkRegex.exec(html)) !== null) {
+    const href = match[1];
+    if (href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:"))
+      continue;
+    try {
+      const resolved = new URL(href, baseUrl);
+      if (resolved.hostname === domain)
+        count++;
+    } catch {
+      if (href.startsWith("/"))
+        count++;
+    }
+  }
+  return count;
+}
+function validateMeta(html, url, responseTime) {
+  const checks = [];
+  const title = extractTitle(html);
+  if (!title) {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "error",
+      message: "Missing <title> tag",
+      remediation: "Add a <title> tag with 30-60 characters describing the page content."
+    });
+  } else if (title.length < 30) {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "warning",
+      message: `Title too short (${title.length} chars): "${title}"`,
+      remediation: "Expand title to 30-60 characters."
+    });
+  } else if (title.length > 60) {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "warning",
+      message: `Title too long (${title.length} chars): "${title}"`,
+      remediation: "Shorten title to 30-60 characters to avoid truncation in SERPs."
+    });
+  } else {
+    checks.push({
+      name: "title-tag",
+      category: "meta",
+      severity: "pass",
+      message: `Title OK (${title.length} chars): "${title}"`
+    });
+  }
+  const description = extractMetaContent(html, "description");
+  if (!description) {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "error",
+      message: 'Missing <meta name="description">',
+      remediation: "Add a meta description with 120-160 characters summarizing the page."
+    });
+  } else if (description.length < 120) {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "warning",
+      message: `Description too short (${description.length} chars)`,
+      remediation: "Expand description to 120-160 characters."
+    });
+  } else if (description.length > 160) {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "warning",
+      message: `Description too long (${description.length} chars)`,
+      remediation: "Shorten description to 120-160 characters."
+    });
+  } else {
+    checks.push({
+      name: "meta-description",
+      category: "meta",
+      severity: "pass",
+      message: `Description OK (${description.length} chars)`
+    });
+  }
+  const canonical = extractCanonical(html);
+  if (!canonical) {
+    checks.push({
+      name: "canonical",
+      category: "meta",
+      severity: "warning",
+      message: 'Missing <link rel="canonical">',
+      remediation: "Add a canonical URL to prevent duplicate content issues."
+    });
+  } else if (canonical !== url) {
+    checks.push({
+      name: "canonical",
+      category: "meta",
+      severity: "info",
+      message: `Canonical (${canonical}) differs from current URL (${url})`
+    });
+  } else {
+    checks.push({
+      name: "canonical",
+      category: "meta",
+      severity: "pass",
+      message: `Canonical matches URL`
+    });
+  }
+  const robots = extractMetaContent(html, "robots");
+  if (robots) {
+    if (/noindex/i.test(robots)) {
+      checks.push({
+        name: "robots-noindex",
+        category: "crawl",
+        severity: "warning",
+        message: `Page has noindex directive: "${robots}"`,
+        remediation: "Remove noindex if this page should appear in search results."
+      });
+    }
+    if (/nofollow/i.test(robots)) {
+      checks.push({
+        name: "robots-nofollow",
+        category: "crawl",
+        severity: "warning",
+        message: `Page has nofollow directive: "${robots}"`
+      });
+    }
+  } else {
+    checks.push({
+      name: "robots-directive",
+      category: "crawl",
+      severity: "pass",
+      message: "No restrictive robots directive"
+    });
+  }
+  const hreflangRegex = /hreflang=["']([^"']*)["']/gi;
+  const hreflangs = [];
+  let hreflangMatch;
+  while ((hreflangMatch = hreflangRegex.exec(html)) !== null) {
+    hreflangs.push(hreflangMatch[1]);
+  }
+  if (hreflangs.length > 0) {
+    checks.push({
+      name: "hreflang",
+      category: "meta",
+      severity: "pass",
+      message: `Found ${hreflangs.length} hreflang tags: ${hreflangs.join(", ")}`
+    });
+  }
+  const ogTitle = extractPropertyContent(html, "og:title");
+  const ogDescription = extractPropertyContent(html, "og:description");
+  const ogImage = extractPropertyContent(html, "og:image");
+  const ogUrl = extractPropertyContent(html, "og:url");
+  if (!ogTitle) {
+    checks.push({
+      name: "og-title",
+      category: "social",
+      severity: "warning",
+      message: "Missing og:title",
+      remediation: 'Add <meta property="og:title" content="..."> for social sharing.'
+    });
+  } else {
+    checks.push({ name: "og-title", category: "social", severity: "pass", message: "og:title present" });
+  }
+  if (!ogDescription) {
+    checks.push({
+      name: "og-description",
+      category: "social",
+      severity: "warning",
+      message: "Missing og:description",
+      remediation: 'Add <meta property="og:description" content="...">.'
+    });
+  } else {
+    checks.push({ name: "og-description", category: "social", severity: "pass", message: "og:description present" });
+  }
+  if (!ogImage) {
+    checks.push({
+      name: "og-image",
+      category: "social",
+      severity: "warning",
+      message: "Missing og:image",
+      remediation: 'Add <meta property="og:image" content="..."> with a 1200x630px image.'
+    });
+  } else {
+    checks.push({ name: "og-image", category: "social", severity: "pass", message: "og:image present" });
+  }
+  if (!ogUrl) {
+    checks.push({
+      name: "og-url",
+      category: "social",
+      severity: "info",
+      message: "Missing og:url"
+    });
+  }
+  const twitterCard = extractMetaContent(html, "twitter:card");
+  if (!twitterCard) {
+    checks.push({
+      name: "twitter-card",
+      category: "social",
+      severity: "info",
+      message: "Missing twitter:card",
+      remediation: 'Add <meta name="twitter:card" content="summary_large_image">.'
+    });
+  } else {
+    checks.push({ name: "twitter-card", category: "social", severity: "pass", message: `twitter:card: ${twitterCard}` });
+  }
+  const h1Tags = extractH1Tags(html);
+  if (h1Tags.length === 0) {
+    checks.push({
+      name: "h1-tag",
+      category: "content",
+      severity: "error",
+      message: "Missing <h1> tag",
+      remediation: "Add exactly one <h1> tag with the main page heading."
+    });
+  } else if (h1Tags.length > 1) {
+    checks.push({
+      name: "h1-tag",
+      category: "content",
+      severity: "warning",
+      message: `Multiple <h1> tags found (${h1Tags.length}): "${h1Tags.join('", "')}"`,
+      remediation: "Use only one <h1> per page. Convert extras to <h2>."
+    });
+  } else {
+    checks.push({
+      name: "h1-tag",
+      category: "content",
+      severity: "pass",
+      message: `H1 OK: "${h1Tags[0]}"`
+    });
+  }
+  const headings = extractHeadingHierarchy(html);
+  if (headings.length > 1) {
+    let hasSkips = false;
+    for (let i = 1;i < headings.length; i++) {
+      const prev = parseInt(headings[i - 1].tag[1]);
+      const curr = parseInt(headings[i].tag[1]);
+      if (curr > prev + 1) {
+        hasSkips = true;
+        break;
+      }
+    }
+    if (hasSkips) {
+      checks.push({
+        name: "heading-hierarchy",
+        category: "content",
+        severity: "warning",
+        message: "Heading hierarchy has skipped levels (e.g., h2 → h4)",
+        remediation: "Ensure headings follow sequential order: h1 → h2 → h3."
+      });
+    } else {
+      checks.push({
+        name: "heading-hierarchy",
+        category: "content",
+        severity: "pass",
+        message: `Heading hierarchy OK (${headings.length} headings)`
+      });
+    }
+  }
+  const imgsWithoutAlt = extractImgWithoutAlt(html);
+  if (imgsWithoutAlt > 0) {
+    checks.push({
+      name: "img-alt-text",
+      category: "content",
+      severity: "warning",
+      message: `${imgsWithoutAlt} image(s) missing alt text`,
+      remediation: "Add descriptive alt text to all images for accessibility and SEO."
+    });
+  } else {
+    checks.push({
+      name: "img-alt-text",
+      category: "content",
+      severity: "pass",
+      message: "All images have alt text"
+    });
+  }
+  const internalLinks = extractInternalLinks(html, url);
+  checks.push({
+    name: "internal-links",
+    category: "content",
+    severity: internalLinks > 0 ? "pass" : "warning",
+    message: `${internalLinks} internal links found`,
+    remediation: internalLinks === 0 ? "Add internal links to improve crawlability and page authority." : undefined
+  });
+  const lang = extractHtmlLang(html);
+  if (!lang) {
+    checks.push({
+      name: "html-lang",
+      category: "technical",
+      severity: "warning",
+      message: 'Missing <html lang="..."> attribute',
+      remediation: 'Add lang attribute to <html> tag (e.g., lang="en").'
+    });
+  } else {
+    checks.push({
+      name: "html-lang",
+      category: "technical",
+      severity: "pass",
+      message: `HTML lang: ${lang}`
+    });
+  }
+  const viewport = extractViewport(html);
+  if (!viewport) {
+    checks.push({
+      name: "viewport",
+      category: "technical",
+      severity: "error",
+      message: 'Missing <meta name="viewport">',
+      remediation: 'Add <meta name="viewport" content="width=device-width, initial-scale=1">.'
+    });
+  } else {
+    checks.push({
+      name: "viewport",
+      category: "technical",
+      severity: "pass",
+      message: "Viewport meta tag present"
+    });
+  }
+  const isHttps = url.startsWith("https://");
+  checks.push({
+    name: "https",
+    category: "technical",
+    severity: isHttps ? "pass" : "error",
+    message: isHttps ? "HTTPS enabled" : "Site is not using HTTPS",
+    remediation: isHttps ? undefined : "Migrate to HTTPS for security and SEO ranking."
+  });
+  if (responseTime < 3000) {
+    checks.push({
+      name: "response-time",
+      category: "technical",
+      severity: "pass",
+      message: `Response time: ${responseTime}ms`
+    });
+  } else if (responseTime < 5000) {
+    checks.push({
+      name: "response-time",
+      category: "technical",
+      severity: "warning",
+      message: `Slow response time: ${responseTime}ms`,
+      remediation: "Optimize server response time to under 3 seconds."
+    });
+  } else {
+    checks.push({
+      name: "response-time",
+      category: "technical",
+      severity: "error",
+      message: `Very slow response time: ${responseTime}ms`,
+      remediation: "Server response time exceeds 5 seconds. Investigate server performance."
+    });
+  }
+  return checks;
+}
+
+// src/domain/seo/schema-validator.ts
+var HOTEL_TYPES = [
+  "Hotel",
+  "LodgingBusiness",
+  "HotelRoom",
+  "LocalBusiness",
+  "Resort",
+  "Motel",
+  "Hostel",
+  "BedAndBreakfast",
+  "Campground",
+  "RV Park"
+];
+var SUPPORTING_TYPES = [
+  "BreadcrumbList",
+  "FAQPage",
+  "Review",
+  "AggregateRating",
+  "Organization",
+  "WebSite",
+  "ImageObject",
+  "Event",
+  "TouristAttraction",
+  "HowTo",
+  "WebPage",
+  "Person"
+];
+var REQUIRED_HOTEL_PROPERTIES = ["name", "address", "telephone", "image"];
+var RECOMMENDED_HOTEL_PROPERTIES = ["priceRange", "description", "url", "geo"];
+function extractJsonLdBlocks(html) {
+  const regex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  const blocks = [];
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (const item of items) {
+        if (item && typeof item === "object" && "@type" in item) {
+          blocks.push({
+            type: String(item["@type"]),
+            properties: item,
+            raw: match[1].trim()
+          });
+        }
+      }
+    } catch {}
+  }
+  return blocks;
+}
+function validateHotelSchema(block) {
+  const errors3 = [];
+  const warnings = [];
+  for (const prop of REQUIRED_HOTEL_PROPERTIES) {
+    if (!(prop in block.properties)) {
+      errors3.push(`Missing required property: ${prop}`);
+    }
+  }
+  for (const prop of RECOMMENDED_HOTEL_PROPERTIES) {
+    if (!(prop in block.properties)) {
+      warnings.push(`Missing recommended property: ${prop}`);
+    }
+  }
+  if ("address" in block.properties) {
+    const address = block.properties.address;
+    if (typeof address === "object" && address !== null) {
+      const addrObj = address;
+      if (!("streetAddress" in addrObj) && !("addressLocality" in addrObj)) {
+        errors3.push("Address missing streetAddress or addressLocality");
+      }
+    }
+  }
+  if ("image" in block.properties) {
+    const image = block.properties.image;
+    if (typeof image === "string" && !image.startsWith("http")) {
+      warnings.push("Image URL should be absolute");
+    }
+  }
+  return {
+    valid: errors3.length === 0,
+    type: block.type,
+    errors: errors3,
+    warnings
+  };
+}
+function validateSupportingSchema(block) {
+  const errors3 = [];
+  const warnings = [];
+  if (block.type === "BreadcrumbList") {
+    if (!("itemListElement" in block.properties)) {
+      errors3.push("BreadcrumbList missing itemListElement");
+    }
+  }
+  if (block.type === "FAQPage") {
+    if (!("mainEntity" in block.properties)) {
+      errors3.push("FAQPage missing mainEntity");
+    }
+  }
+  if (block.type === "AggregateRating") {
+    if (!("ratingValue" in block.properties)) {
+      errors3.push("AggregateRating missing ratingValue");
+    }
+    if (!("reviewCount" in block.properties) && !("ratingCount" in block.properties)) {
+      warnings.push("AggregateRating missing reviewCount or ratingCount");
+    }
+  }
+  if (block.type === "Organization") {
+    if (!("name" in block.properties)) {
+      errors3.push("Organization missing name");
+    }
+    if (!("url" in block.properties)) {
+      warnings.push("Organization missing url");
+    }
+  }
+  return {
+    valid: errors3.length === 0,
+    type: block.type,
+    errors: errors3,
+    warnings
+  };
+}
+function validateSchema(html) {
+  const checks = [];
+  const blocks = extractJsonLdBlocks(html);
+  if (blocks.length === 0) {
+    checks.push({
+      name: "json-ld-presence",
+      category: "schema",
+      severity: "error",
+      message: "No JSON-LD structured data found",
+      remediation: 'Add <script type="application/ld+json"> with Hotel or LodgingBusiness schema.'
+    });
+    return checks;
+  }
+  checks.push({
+    name: "json-ld-presence",
+    category: "schema",
+    severity: "pass",
+    message: `Found ${blocks.length} JSON-LD block(s)`
+  });
+  const hotelBlocks = blocks.filter((b) => HOTEL_TYPES.includes(b.type));
+  const supportingBlocks = blocks.filter((b) => SUPPORTING_TYPES.includes(b.type));
+  const unknownBlocks = blocks.filter((b) => !HOTEL_TYPES.includes(b.type) && !SUPPORTING_TYPES.includes(b.type));
+  if (hotelBlocks.length === 0) {
+    checks.push({
+      name: "hotel-schema",
+      category: "schema",
+      severity: "error",
+      message: `No Hotel/Hospitality schema found. Types found: ${blocks.map((b) => b.type).join(", ")}`,
+      remediation: "Add a Hotel, LodgingBusiness, or Resort schema with required properties."
+    });
+  }
+  for (const block of hotelBlocks) {
+    const result = validateHotelSchema(block);
+    if (result.valid) {
+      checks.push({
+        name: `schema-${block.type}`,
+        category: "schema",
+        severity: "pass",
+        message: `${block.type} schema valid`
+      });
+    } else {
+      checks.push({
+        name: `schema-${block.type}`,
+        category: "schema",
+        severity: "error",
+        message: `${block.type} schema invalid: ${result.errors.join("; ")}`,
+        remediation: `Fix the following properties: ${result.errors.join(", ")}`
+      });
+    }
+    if (result.warnings.length > 0) {
+      checks.push({
+        name: `schema-${block.type}-warnings`,
+        category: "schema",
+        severity: "warning",
+        message: `${block.type} recommendations: ${result.warnings.join("; ")}`
+      });
+    }
+  }
+  for (const block of supportingBlocks) {
+    const result = validateSupportingSchema(block);
+    checks.push({
+      name: `schema-${block.type}`,
+      category: "schema",
+      severity: result.valid ? "pass" : "warning",
+      message: result.valid ? `${block.type} schema valid` : `${block.type} schema issues: ${result.errors.join("; ")}`
+    });
+  }
+  for (const block of unknownBlocks) {
+    checks.push({
+      name: `schema-${block.type}`,
+      category: "schema",
+      severity: "info",
+      message: `Unknown schema type: ${block.type}`
+    });
+  }
+  return checks;
+}
+
+// src/domain/seo/geo-validator.ts
+function hasFactualStatements(html) {
+  const bodyText = html.replace(/<[^>]*>/g, " ");
+  const numberPattern = /\d{2,}/g;
+  const datePattern = /\b(20\d{2}|19\d{2})\b/g;
+  const properNounPattern = /\b[A-Z][a-z]{2,}\b/g;
+  const numbers = bodyText.match(numberPattern) ?? [];
+  const dates = bodyText.match(datePattern) ?? [];
+  const properNouns = bodyText.match(properNounPattern) ?? [];
+  return numbers.length >= 3 || dates.length >= 1 || properNouns.length >= 5;
+}
+function countStructuredLists(html) {
+  const ulMatches = html.match(/<ul[^>]*>/gi) ?? [];
+  const olMatches = html.match(/<ol[^>]*>/gi) ?? [];
+  const dlMatches = html.match(/<dl[^>]*>/gi) ?? [];
+  return ulMatches.length + olMatches.length + dlMatches.length;
+}
+function hasFaqSection(html) {
+  const patterns = [
+    /faqpage/i,
+    /<details[^>]*>/i,
+    /id=["'][^"']*faq[^"']*["']/i,
+    /class=["'][^"']*faq[^"']*["']/i,
+    /<h[2-4][^>]*>.*(?:faq|frequently asked)/i
+  ];
+  return patterns.some((p) => p.test(html));
+}
+function hasContentDates(html) {
+  const timeRegex2 = /<time[^>]*datetime=["']([^"']*)["']/gi;
+  let match;
+  while ((match = timeRegex2.exec(html)) !== null) {
+    return true;
+  }
+  const datePattern = /\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}\b/i;
+  return datePattern.test(html);
+}
+function validateGeo(html, url) {
+  const checks = [];
+  if (hasFactualStatements(html)) {
+    checks.push({
+      name: "citable-content",
+      category: "geo",
+      severity: "pass",
+      message: "Page contains factual statements suitable for AI citation"
+    });
+  } else {
+    checks.push({
+      name: "citable-content",
+      category: "geo",
+      severity: "warning",
+      message: "Page lacks factual statements (numbers, dates, proper nouns) for AI citation",
+      remediation: "Add specific facts, numbers, and named entities that AI assistants can cite."
+    });
+  }
+  const listCount = countStructuredLists(html);
+  if (listCount > 0) {
+    checks.push({
+      name: "structured-lists",
+      category: "geo",
+      severity: "pass",
+      message: `Found ${listCount} structured list(s) (ul/ol/dl)`
+    });
+  } else {
+    checks.push({
+      name: "structured-lists",
+      category: "geo",
+      severity: "warning",
+      message: "No structured lists found",
+      remediation: "Add <ul> or <ol> lists for amenities, features, and services. AI tools extract structured lists for citations."
+    });
+  }
+  if (hasFaqSection(html)) {
+    checks.push({
+      name: "faq-section",
+      category: "geo",
+      severity: "pass",
+      message: "FAQ section detected"
+    });
+  } else {
+    checks.push({
+      name: "faq-section",
+      category: "geo",
+      severity: "warning",
+      message: "No FAQ section found",
+      remediation: "Add an FAQ section with FAQPage schema. AI search tools prioritize Q&A formatted content."
+    });
+  }
+  if (hasContentDates(html)) {
+    checks.push({
+      name: "content-freshness",
+      category: "geo",
+      severity: "pass",
+      message: "Content has date signals"
+    });
+  } else {
+    checks.push({
+      name: "content-freshness",
+      category: "geo",
+      severity: "info",
+      message: "No date signals found in content",
+      remediation: "Add <time> elements or visible dates to signal content freshness."
+    });
+  }
+  return checks;
+}
+async function checkLlmsTxt(baseUrl) {
+  const checks = [];
+  let root;
+  try {
+    const parsed = new URL(baseUrl);
+    root = `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return [{
+      name: "llms-txt",
+      category: "geo",
+      severity: "error",
+      message: `Invalid base URL: ${baseUrl}`
+    }];
+  }
+  try {
+    const response = await safeFetch(`${root}/llms.txt`);
+    if (response.status === 200 && response.body.length > 0) {
+      checks.push({
+        name: "llms-txt",
+        category: "geo",
+        severity: "pass",
+        message: `llms.txt found (${response.body.length} bytes)`
+      });
+      if (!response.body.startsWith("#")) {
+        checks.push({
+          name: "llms-txt-format",
+          category: "geo",
+          severity: "warning",
+          message: "llms.txt should start with a # heading",
+          remediation: "Format: # Site Name\\n> Description\\n\\n## Pages\\n- [Title](url): description"
+        });
+      } else {
+        checks.push({
+          name: "llms-txt-format",
+          category: "geo",
+          severity: "pass",
+          message: "llms.txt format looks correct"
+        });
+      }
+    } else {
+      checks.push({
+        name: "llms-txt",
+        category: "geo",
+        severity: "error",
+        message: `llms.txt returned status ${response.status}`,
+        remediation: "Create a llms.txt file at the site root following the llms.txt specification."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "llms-txt",
+      category: "geo",
+      severity: "error",
+      message: "llms.txt not found or unreachable",
+      remediation: "Create a llms.txt file at the site root. Use `codeconductor seo llms` to generate one."
+    });
+  }
+  try {
+    const response = await safeFetch(`${root}/llms-full.txt`);
+    if (response.status === 200 && response.body.length > 0) {
+      checks.push({
+        name: "llms-full-txt",
+        category: "geo",
+        severity: "pass",
+        message: `llms-full.txt found (${response.body.length} bytes)`
+      });
+    }
+  } catch {
+    checks.push({
+      name: "llms-full-txt",
+      category: "geo",
+      severity: "info",
+      message: "llms-full.txt not found (optional)",
+      remediation: "Consider creating llms-full.txt with extended content for AI tools."
+    });
+  }
+  return checks;
+}
+
+// src/domain/seo/seo-auditor.ts
+function computeSummary(pages) {
+  let passed = 0;
+  let warnings = 0;
+  let errors3 = 0;
+  let total = 0;
+  for (const page of pages) {
+    for (const check of page.checks) {
+      total++;
+      if (check.severity === "pass")
+        passed++;
+      else if (check.severity === "warning" || check.severity === "info")
+        warnings++;
+      else if (check.severity === "error")
+        errors3++;
+    }
+  }
+  const score = total > 0 ? Math.round(passed / total * 100) : 0;
+  return { total, passed, warnings, errors: errors3, score };
+}
+async function auditSingleUrl(url, options = {}) {
+  const response = await safeFetch(url, {
+    followRedirects: options.followRedirects ?? false
+  });
+  const html = response.body;
+  const checks = [];
+  checks.push(...validateMeta(html, url, response.responseTime));
+  checks.push(...validateSchema(html));
+  checks.push(...validateGeo(html, url));
+  return {
+    url,
+    checks,
+    responseTime: response.responseTime
+  };
+}
+async function auditSitemap(sitemapUrl, options = {}) {
+  const { delay: requestDelay = 500, followRedirects = false, maxUrls, onProgress } = options;
+  const sitemapResult = await parseSitemap(sitemapUrl, { delay: requestDelay });
+  let entries = sitemapResult.entries;
+  if (maxUrls && entries.length > maxUrls) {
+    entries = entries.slice(0, maxUrls);
+  }
+  const pages = [];
+  for (let i = 0;i < entries.length; i++) {
+    const entry = entries[i];
+    if (onProgress) {
+      onProgress(i + 1, entries.length, entry.url);
+    }
+    if (i > 0 && requestDelay > 0) {
+      await delay(requestDelay);
+    }
+    try {
+      const result = await auditSingleUrl(entry.url, { followRedirects });
+      pages.push(result);
+    } catch (error) {
+      pages.push({
+        url: entry.url,
+        checks: [{
+          name: "fetch-error",
+          category: "technical",
+          severity: "error",
+          message: `Failed to fetch: ${String(error)}`
+        }],
+        responseTime: 0
+      });
+    }
+  }
+  try {
+    let siteRoot;
+    try {
+      const parsed = new URL(sitemapUrl);
+      siteRoot = `${parsed.protocol}//${parsed.host}`;
+    } catch {
+      siteRoot = sitemapUrl;
+    }
+    const llmsChecks = await checkLlmsTxt(siteRoot);
+    if (pages.length > 0) {
+      pages[0] = {
+        ...pages[0],
+        checks: [...pages[0].checks, ...llmsChecks]
+      };
+    }
+  } catch {}
+  const summary = computeSummary(pages);
+  return {
+    target: sitemapUrl,
+    timestamp: new Date().toISOString(),
+    pages,
+    summary
+  };
+}
+async function auditUrl(url, options = {}) {
+  const page = await auditSingleUrl(url, options);
+  try {
+    const llmsChecks = await checkLlmsTxt(url);
+    page.checks.push(...llmsChecks);
+  } catch {}
+  const summary = computeSummary([page]);
+  return {
+    target: url,
+    timestamp: new Date().toISOString(),
+    pages: [page],
+    summary
+  };
+}
+
+// src/domain/seo/report-formatter.ts
+var SEVERITY_ICONS = {
+  pass: "✓",
+  warning: "⚠",
+  error: "✗",
+  info: "ℹ"
+};
+var SEVERITY_COLORS = {
+  pass: "\x1B[32m",
+  warning: "\x1B[33m",
+  error: "\x1B[31m",
+  info: "\x1B[36m"
+};
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+function formatCli(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(`${BOLD}SEO Audit Report${RESET}`);
+  lines.push(`${DIM}Target: ${report.target}${RESET}`);
+  lines.push(`${DIM}Time: ${report.timestamp}${RESET}`);
+  lines.push(`${DIM}Pages: ${report.pages.length}${RESET}`);
+  lines.push("");
+  for (const page of report.pages) {
+    lines.push(`${BOLD}── ${page.url} (${page.responseTime}ms) ──${RESET}`);
+    const grouped = groupByCategory(page.checks);
+    for (const [category, checks] of grouped) {
+      lines.push(`  ${DIM}${category}${RESET}`);
+      for (const check of checks) {
+        const icon = SEVERITY_ICONS[check.severity];
+        const color = SEVERITY_COLORS[check.severity];
+        lines.push(`    ${color}${icon}${RESET} ${check.name}: ${check.message}`);
+        if (check.remediation && check.severity !== "pass") {
+          lines.push(`      ${DIM}→ ${check.remediation}${RESET}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  const { summary } = report;
+  lines.push(`${BOLD}Summary${RESET}`);
+  lines.push(`  Score: ${summary.score}%`);
+  lines.push(`  ${SEVERITY_COLORS.pass}✓ ${summary.passed} passed${RESET}`);
+  lines.push(`  ${SEVERITY_COLORS.warning}⚠ ${summary.warnings} warnings${RESET}`);
+  lines.push(`  ${SEVERITY_COLORS.error}✗ ${summary.errors} errors${RESET}`);
+  lines.push(`  Total checks: ${summary.total}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function formatMarkdown(report) {
+  const lines = [];
+  lines.push("# SEO Audit Report");
+  lines.push("");
+  lines.push(`- **Target:** ${report.target}`);
+  lines.push(`- **Date:** ${report.timestamp}`);
+  lines.push(`- **Pages audited:** ${report.pages.length}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Score | ${report.summary.score}% |`);
+  lines.push(`| Passed | ${report.summary.passed} |`);
+  lines.push(`| Warnings | ${report.summary.warnings} |`);
+  lines.push(`| Errors | ${report.summary.errors} |`);
+  lines.push(`| Total checks | ${report.summary.total} |`);
+  lines.push("");
+  for (const page of report.pages) {
+    lines.push(`## ${page.url}`);
+    lines.push("");
+    lines.push(`Response time: ${page.responseTime}ms`);
+    lines.push("");
+    const errors3 = page.checks.filter((c) => c.severity === "error");
+    const warnings = page.checks.filter((c) => c.severity === "warning");
+    const passed = page.checks.filter((c) => c.severity === "pass");
+    const info = page.checks.filter((c) => c.severity === "info");
+    if (errors3.length > 0) {
+      lines.push("### Errors");
+      lines.push("");
+      for (const check of errors3) {
+        lines.push(`- **${check.name}** (${check.category}): ${check.message}`);
+        if (check.remediation) {
+          lines.push(`  - Fix: ${check.remediation}`);
+        }
+      }
+      lines.push("");
+    }
+    if (warnings.length > 0) {
+      lines.push("### Warnings");
+      lines.push("");
+      for (const check of warnings) {
+        lines.push(`- **${check.name}** (${check.category}): ${check.message}`);
+        if (check.remediation) {
+          lines.push(`  - Fix: ${check.remediation}`);
+        }
+      }
+      lines.push("");
+    }
+    if (passed.length > 0) {
+      lines.push("### Passed");
+      lines.push("");
+      for (const check of passed) {
+        lines.push(`- ${check.name}: ${check.message}`);
+      }
+      lines.push("");
+    }
+    if (info.length > 0) {
+      lines.push("### Info");
+      lines.push("");
+      for (const check of info) {
+        lines.push(`- ${check.name}: ${check.message}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(`*Generated by CodeConductor SEO Audit on ${report.timestamp.split("T")[0]}*`);
+  return lines.join(`
+`);
+}
+function groupByCategory(checks) {
+  const groups = new Map;
+  for (const check of checks) {
+    if (!groups.has(check.category)) {
+      groups.set(check.category, []);
+    }
+    groups.get(check.category).push(check);
+  }
+  return groups;
+}
+function computeExitCode(report, failOn) {
+  if (report.summary.errors > 0)
+    return 1;
+  if (failOn === "warning" && report.summary.warnings > 0)
+    return 2;
+  if (report.summary.warnings > 0)
+    return 0;
+  return 0;
+}
+
+// src/commands/seo-audit.command.ts
+async function seoAuditCommand(options) {
+  const { url, sitemap, format, failOn, delay: delay2, output, followRedirects } = options;
+  if (!url && !sitemap) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "seo audit",
+        errors: ["Either --url or --sitemap is required"]
+      }
+    };
+  }
+  try {
+    const report = sitemap ? await auditSitemap(sitemap, {
+      delay: delay2,
+      followRedirects,
+      onProgress: format === "cli" ? (current, total, pageUrl) => {
+        process.stderr.write(`\r  Auditing ${current}/${total}: ${pageUrl}`);
+      } : undefined
+    }) : await auditUrl(url, { followRedirects });
+    if (format === "cli") {
+      process.stderr.write("\r" + " ".repeat(80) + "\r");
+    }
+    let formattedOutput;
+    switch (format) {
+      case "json":
+        formattedOutput = formatJson(report);
+        break;
+      case "markdown":
+        formattedOutput = formatMarkdown(report);
+        break;
+      default:
+        formattedOutput = formatCli(report);
+    }
+    if (output) {
+      const outputPath = resolve9(options.projectRoot, output);
+      await mkdir6(dirname4(outputPath), { recursive: true });
+      await writeFile5(outputPath, formattedOutput, "utf-8");
+    } else if (format === "markdown") {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const defaultPath = resolve9(options.projectRoot, "seo-reports", `audit-report-${timestamp}.md`);
+      await mkdir6(dirname4(defaultPath), { recursive: true });
+      await writeFile5(defaultPath, formattedOutput, "utf-8");
+      process.stderr.write(`Report saved to: ${defaultPath}
+`);
+    }
+    const exitCode = computeExitCode(report, failOn);
+    return {
+      code: exitCode,
+      data: {
+        success: true,
+        command: "seo audit",
+        report,
+        output: formattedOutput,
+        outputFile: output ? resolve9(options.projectRoot, output) : format === "markdown" ? resolve9(options.projectRoot, "seo-reports") : undefined
+      }
+    };
+  } catch (error) {
+    return {
+      code: 3,
+      data: {
+        success: false,
+        command: "seo audit",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
+// src/commands/seo-llms.command.ts
+import { writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
+import { dirname as dirname5, resolve as resolve10 } from "node:path";
+
+// src/domain/seo/llms-generator.ts
+function extractTitle2(html) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? match[1].trim() : "";
+}
+function extractDescription(html) {
+  const patterns = [
+    /<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/i,
+    /<meta[^>]*content=["']([^"']*)["'][^>]*name=["']description["']/i,
+    /<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']*)["']/i
+  ];
+  for (const pattern of patterns) {
+    const match = html.match(pattern);
+    if (match)
+      return match[1].trim();
+  }
+  return "";
+}
+function extractFirstParagraph(html) {
+  const bodyHtml = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "");
+  const match = bodyHtml.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+  if (!match)
+    return "";
+  return match[1].replace(/<[^>]*>/g, "").trim().slice(0, 200);
+}
+function groupByPathSegment(entries) {
+  const groups = new Map;
+  for (const entry of entries) {
+    try {
+      const parsed = new URL(entry.url);
+      const segments = parsed.pathname.split("/").filter(Boolean);
+      const group = segments.length > 0 ? `/${segments[0]}/` : "/";
+      if (!groups.has(group)) {
+        groups.set(group, []);
+      }
+      groups.get(group).push(entry);
+    } catch {
+      if (!groups.has("/")) {
+        groups.set("/", []);
+      }
+      groups.get("/").push(entry);
+    }
+  }
+  return groups;
+}
+function formatLlmsTxt(siteName, siteDescription, entries) {
+  const lines = [];
+  lines.push(`# ${siteName}`);
+  if (siteDescription) {
+    lines.push(`> ${siteDescription}`);
+  }
+  lines.push("");
+  const groups = groupByPathSegment(entries);
+  for (const [group, groupEntries] of groups) {
+    const groupName = group === "/" ? "Main Pages" : group.replace(/\//g, "").replace(/-/g, " ");
+    lines.push(`## ${groupName.charAt(0).toUpperCase() + groupName.slice(1)}`);
+    lines.push("");
+    for (const entry of groupEntries) {
+      const desc = entry.description ? `: ${entry.description}` : "";
+      lines.push(`- [${entry.title}](${entry.url})${desc}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push(`Generated by CodeConductor SEO on ${new Date().toISOString().split("T")[0]}`);
+  return lines.join(`
+`);
+}
+async function generateLlmsTxtFromSitemap(sitemapUrl, options = {}) {
+  const { delay: requestDelay = 500, maxUrls, onProgress } = options;
+  const sitemapResult = await parseSitemap(sitemapUrl, { delay: requestDelay });
+  let urls = sitemapResult.entries.map((e) => e.url);
+  if (maxUrls && urls.length > maxUrls) {
+    urls = urls.slice(0, maxUrls);
+  }
+  const entries = [];
+  let siteName = "";
+  let siteDescription = "";
+  for (let i = 0;i < urls.length; i++) {
+    const url = urls[i];
+    if (onProgress) {
+      onProgress(i + 1, urls.length, url);
+    }
+    if (i > 0 && requestDelay > 0) {
+      await delay(requestDelay);
+    }
+    try {
+      const response = await safeFetch(url);
+      const html = response.body;
+      const title = extractTitle2(html) || url;
+      const description = extractDescription(html) || extractFirstParagraph(html);
+      if (i === 0) {
+        siteName = title;
+        siteDescription = extractDescription(html);
+      }
+      entries.push({ title, url, description });
+    } catch {
+      entries.push({ title: url, url, description: "" });
+    }
+  }
+  if (!siteName) {
+    try {
+      siteName = new URL(sitemapUrl).hostname;
+    } catch {
+      siteName = "Site";
+    }
+  }
+  const content = formatLlmsTxt(siteName, siteDescription, entries);
+  return { content, entries };
+}
+async function generateLlmsTxtFromUrl(url) {
+  const response = await safeFetch(url);
+  const html = response.body;
+  const title = extractTitle2(html) || url;
+  const description = extractDescription(html) || extractFirstParagraph(html);
+  const entries = [{ title, url, description }];
+  const content = formatLlmsTxt(title, description, entries);
+  return { content, entries };
+}
+
+// src/commands/seo-llms.command.ts
+async function seoLlmsCommand(options) {
+  const { url, sitemap, output, delay: delay2 } = options;
+  if (!url && !sitemap) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "seo llms",
+        errors: ["Either --url or --sitemap is required"]
+      }
+    };
+  }
+  try {
+    const result = sitemap ? await generateLlmsTxtFromSitemap(sitemap, {
+      delay: delay2,
+      onProgress: (current, total, pageUrl) => {
+        process.stderr.write(`\r  Processing ${current}/${total}: ${pageUrl}`);
+      }
+    }) : await generateLlmsTxtFromUrl(url);
+    process.stderr.write("\r" + " ".repeat(80) + "\r");
+    const outputPath = output ? resolve10(options.projectRoot, output) : resolve10(options.projectRoot, "llms.txt");
+    await mkdir7(dirname5(outputPath), { recursive: true });
+    await writeFile6(outputPath, result.content, "utf-8");
+    process.stderr.write(`Generated: ${outputPath} (${result.entries.length} entries)
+`);
+    return {
+      code: 0,
+      data: {
+        success: true,
+        command: "seo llms",
+        outputFile: outputPath,
+        entries: result.entries.length,
+        content: result.content
+      }
+    };
+  } catch (error) {
+    return {
+      code: 3,
+      data: {
+        success: false,
+        command: "seo llms",
+        errors: [String(error)]
+      }
+    };
+  }
+}
+
 // src/commands/update.command.ts
 async function updateCommand(options) {
   const { dryRun, force, output, projectRoot } = options;
@@ -13599,6 +15092,8 @@ Commands:
   install council        Install generated council spec files to runner targets
   install preset         Install full preset (agents, prompts, skills, commands)
   install lsp            Install and configure LSP servers for AI coding tools
+  seo audit              Run SEO audit on a URL or sitemap
+  seo llms               Generate llms.txt from a URL or sitemap
   doctor                 Validate configuration and generated files
   update                 Update installed presets
 
@@ -13629,6 +15124,11 @@ Examples:
   npx cc-codeconductor install lsp --target claude --dry-run
   npx cc-codeconductor doctor
   npx cc-codeconductor update --dry-run
+  npx cc-codeconductor seo audit --url https://example.com
+  npx cc-codeconductor seo audit --sitemap https://example.com/sitemap.xml
+  npx cc-codeconductor seo audit --sitemap https://example.com/sitemap.xml --format markdown
+  npx cc-codeconductor seo llms --sitemap https://example.com/sitemap.xml
+  npx cc-codeconductor seo llms --url https://example.com --output llms.txt
 `;
 }
 async function routeCommand(args, projectRoot) {
@@ -13701,6 +15201,37 @@ async function routeCommand(args, projectRoot) {
         force: flags.force,
         output: flags.output
       });
+    case "seo": {
+      if (subcommand === "audit") {
+        return seoAuditCommand({
+          url: options.url,
+          sitemap: options.sitemap,
+          format: options.format ?? (flags.output === "json" ? "json" : "cli"),
+          failOn: options["fail-on"] ?? "error",
+          delay: options.delay ? parseInt(String(options.delay), 10) : 500,
+          output: options.output,
+          followRedirects: options["follow-redirects"] === true,
+          projectRoot
+        });
+      }
+      if (subcommand === "llms") {
+        return seoLlmsCommand({
+          url: options.url,
+          sitemap: options.sitemap,
+          output: options.output,
+          delay: options.delay ? parseInt(String(options.delay), 10) : 500,
+          projectRoot
+        });
+      }
+      return {
+        code: 1,
+        data: {
+          success: false,
+          command: "seo",
+          errors: ["Usage: seo audit|llms. Run `codeconductor seo audit --help` for details."]
+        }
+      };
+    }
     default:
       return {
         code: 1,
@@ -13792,6 +15323,8 @@ ${count} files processed${errCount > 0 ? `, ${errCount} errors` : ""}${note}`);
                 console.log(`  - ${key}: ${value}`);
               }
             });
+          } else if ("output" in data && typeof data.output === "string") {
+            console.log(data.output);
           }
         }
       }