agentsite-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,1238 @@
+import {
+  classifyPage,
+  crawlSite,
+  normalizeUrl,
+  parseSitemap,
+  registerScanCommand,
+  urlToId
+} from "./chunk-YWR5EH3F.js";
+import {
+  generateAgentIndex,
+  generateAgentSitemap,
+  generateLlmsTxt,
+  generateStructuredExports,
+  registerGenerateCommand
+} from "./chunk-AYLZUDQP.js";
+import {
+  extractContent,
+  loadConfig,
+  log,
+  sha256,
+  spinner,
+  toSlug
+} from "./chunk-YWUDTSOR.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { createInterface } from "readline";
+import yaml2 from "js-yaml";
+
+// src/templates/registry.ts
+import { readFileSync, existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import yaml from "js-yaml";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var PRESETS_DIR = existsSync(resolve(__dirname, "../../templates/presets")) ? resolve(__dirname, "../../templates/presets") : resolve(__dirname, "../templates/presets");
+var BUILTIN_TEMPLATES = ["docs-site", "blog", "saas", "knowledge-base", "ecommerce", "portfolio", "api-docs", "community"];
+function listTemplates() {
+  const templates = [];
+  for (const id of BUILTIN_TEMPLATES) {
+    const preset = loadTemplate(id);
+    if (preset) templates.push(preset);
+  }
+  return templates;
+}
+function loadTemplate(id) {
+  const filePath = resolve(PRESETS_DIR, `${id}.yaml`);
+  if (!existsSync(filePath)) return null;
+  const raw = readFileSync(filePath, "utf-8");
+  const parsed = yaml.load(raw);
+  return {
+    id,
+    name: parsed.name ?? id,
+    description: parsed.description ?? "",
+    config: parsed.config ?? {}
+  };
+}
+function applyTemplate(baseConfig, template) {
+  return deepMerge(baseConfig, template.config);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sv = source[key];
+    const tv = target[key];
+    if (sv && typeof sv === "object" && !Array.isArray(sv) && tv && typeof tv === "object" && !Array.isArray(tv)) {
+      result[key] = deepMerge(tv, sv);
+    } else {
+      result[key] = sv;
+    }
+  }
+  return result;
+}
+
+// src/commands/init.ts
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize AgentSite config for your website").option("-t, --template <name>", "Use an industry template (docs-site, blog, saas, knowledge-base, ecommerce, portfolio, api-docs, community)").option("--list-templates", "List available templates").action(async (opts) => {
+    if (opts.listTemplates) {
+      const templates = listTemplates();
+      if (templates.length === 0) {
+        log.warn("No templates found.");
+        return;
+      }
+      log.info("Available templates:");
+      for (const t of templates) {
+        console.log(`  ${t.id.padEnd(20)} ${t.description}`);
+      }
+      return;
+    }
+    if (existsSync2("agentsite.config.yaml")) {
+      log.warn("agentsite.config.yaml already exists. Overwrite? (y/N)");
+      const confirm = await ask("");
+      if (confirm.toLowerCase() !== "y") {
+        log.info("Aborted.");
+        return;
+      }
+    }
+    const url = normalizeUrl(await ask("Site URL: "));
+    const name = await ask("Site name: ");
+    const description = await ask("Site description: ");
+    let config = {
+      site: { url, name, description },
+      scan: {
+        maxPages: 100,
+        concurrency: 3,
+        delayMs: 200,
+        include: ["**"],
+        exclude: [],
+        respectRobotsTxt: true
+      },
+      output: {
+        dir: ".agentsite",
+        formats: ["llms-txt", "agent-sitemap", "agent-index", "structured"]
+      },
+      server: {
+        port: 3141,
+        rateLimit: { max: 60, timeWindow: "1 minute" },
+        accessLog: true
+      },
+      access: {
+        allowedPages: ["**"],
+        blockedPages: [],
+        allowedTypes: ["docs", "faq", "blog", "product", "pricing", "about", "contact", "changelog"],
+        summaryOnly: false,
+        allowSearch: true
+      }
+    };
+    if (opts.template) {
+      const template = loadTemplate(opts.template);
+      if (!template) {
+        log.error(`Template "${opts.template}" not found. Use --list-templates to see available templates.`);
+        process.exit(1);
+      }
+      config = applyTemplate(config, template);
+      log.info(`Applied template: ${template.name}`);
+    }
+    const yamlContent = yaml2.dump(config, { lineWidth: -1, noRefs: true });
+    writeFileSync("agentsite.config.yaml", yamlContent, "utf-8");
+    mkdirSync(".agentsite/cache/pages", { recursive: true });
+    mkdirSync(".agentsite/data", { recursive: true });
+    log.success("Created agentsite.config.yaml");
+    log.success("Created .agentsite/ directory");
+    log.info("Next: run `agentsite scan` to scan your site.");
+  });
+}
+
+// src/commands/serve.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+
+// src/server/app.ts
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import rateLimit from "@fastify/rate-limit";
+
+// src/utils/access-control.ts
+import { minimatch } from "minimatch";
+function isPageAllowed(page, config) {
+  const { allowedPages, blockedPages, allowedTypes } = config.access;
+  for (const pattern of blockedPages) {
+    if (minimatch(page.url, pattern)) return false;
+  }
+  let matchesAllowed = false;
+  for (const pattern of allowedPages) {
+    if (minimatch(page.url, pattern)) {
+      matchesAllowed = true;
+      break;
+    }
+  }
+  if (!matchesAllowed) return false;
+  return allowedTypes.includes(page.type);
+}
+function filterPageContent(page, config) {
+  if (config.access.summaryOnly) {
+    return {
+      url: page.url,
+      title: page.title,
+      type: page.type,
+      summary: page.summary,
+      updatedAt: page.updatedAt
+    };
+  }
+  return page;
+}
+
+// src/web/dashboard.ts
+var dashboardHtml = `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>AgentSite Kit Dashboard</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:system-ui,sans-serif;background:#f5f5f5;display:flex;min-height:100vh}
+.sidebar{width:220px;background:#1a1a2e;color:#fff;padding:20px 0;position:fixed;height:100vh;overflow-y:auto}
+.sidebar h1{font-size:16px;padding:0 20px 20px;border-bottom:1px solid #333}
+.sidebar nav{padding:10px 0}
+.sidebar a{display:block;padding:10px 20px;color:#aaa;text-decoration:none;font-size:14px;transition:all .2s}
+.sidebar a:hover,.sidebar a.active{background:#16213e;color:#fff}
+.sidebar a .icon{margin-right:8px}
+.main{margin-left:220px;flex:1;padding:20px;min-height:100vh}
+.header{background:#fff;padding:20px;border-radius:8px;margin-bottom:20px;box-shadow:0 2px 4px rgba(0,0,0,0.1)}
+h2{font-size:20px;margin-bottom:5px}
+.subtitle{color:#666;font-size:14px}
+.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:16px;margin-bottom:20px}
+.card{background:#fff;padding:20px;border-radius:8px;box-shadow:0 2px 4px rgba(0,0,0,0.1)}
+.card h3{font-size:14px;margin-bottom:8px;color:#666}
+.stat{font-size:28px;font-weight:bold;color:#0066cc}
+.table-wrap{background:#fff;border-radius:8px;overflow:hidden;box-shadow:0 2px 4px rgba(0,0,0,0.1);margin-bottom:20px}
+table{width:100%;border-collapse:collapse}
+th,td{padding:10px 12px;text-align:left;border-bottom:1px solid #eee;font-size:13px}
+th{background:#f9f9f9;font-weight:600}
+.badge{display:inline-block;padding:3px 8px;border-radius:4px;font-size:11px;font-weight:500}
+.badge-docs{background:#e3f2fd;color:#1976d2}
+.badge-faq{background:#f3e5f5;color:#7b1fa2}
+.badge-blog{background:#e8f5e9;color:#388e3c}
+.badge-product{background:#fff3e0;color:#f57c00}
+.badge-pricing{background:#fce4ec;color:#c2185b}
+.badge-changelog{background:#e0f2f1;color:#00796b}
+.badge-homepage{background:#f5f5f5;color:#616161}
+.badge-about{background:#ede7f6;color:#512da8}
+.badge-contact{background:#e8eaf6;color:#283593}
+.badge-unknown{background:#eceff1;color:#546e7a}
+.toolbar{display:flex;gap:10px;margin-bottom:16px;flex-wrap:wrap}
+.toolbar input,.toolbar select{padding:8px 12px;border:1px solid #ddd;border-radius:6px;font-size:13px}
+.toolbar input{flex:1;min-width:200px}
+.pre-wrap{background:#f8f8f8;border:1px solid #eee;border-radius:6px;padding:16px;font-family:monospace;font-size:12px;white-space:pre-wrap;word-break:break-all;max-height:500px;overflow-y:auto;margin-bottom:16px}
+.file-card{background:#fff;border-radius:8px;box-shadow:0 2px 4px rgba(0,0,0,0.1);margin-bottom:16px;overflow:hidden}
+.file-card .file-header{padding:12px 16px;background:#f9f9f9;font-weight:600;font-size:13px;display:flex;justify-content:space-between;cursor:pointer}
+.file-card .file-body{padding:16px;display:none}
+.file-card.open .file-body{display:block}
+.log-entry{display:grid;grid-template-columns:180px 60px 1fr 60px 80px;gap:8px;padding:8px 12px;border-bottom:1px solid #f0f0f0;font-size:12px;align-items:center}
+.log-entry:hover{background:#f9f9f9}
+.status-2xx{color:#388e3c}.status-4xx{color:#f57c00}.status-5xx{color:#c62828}
+.page-view{display:none}
+.page-view.active{display:block}
+.tab-bar{display:flex;gap:4px;margin-bottom:16px;border-bottom:2px solid #eee;padding-bottom:-2px}
+.tab{padding:8px 16px;cursor:pointer;font-size:13px;color:#666;border-bottom:2px solid transparent;margin-bottom:-2px}
+.tab.active{color:#0066cc;border-bottom-color:#0066cc}
+.site-switcher{padding:10px 20px;margin-top:10px}
+.site-switcher select{width:100%;padding:6px 8px;border-radius:4px;border:1px solid #444;background:#16213e;color:#fff;font-size:12px}
+</style>
+</head>
+<body>
+<div class="sidebar">
+<h1>AgentSite Kit</h1>
+<div class="site-switcher" id="siteSwitcher" style="display:none">
+<select id="siteSelect"></select>
+</div>
+<nav>
+<a href="#/" class="active"><span class="icon">&#9632;</span> Overview</a>
+<a href="#/pages"><span class="icon">&#9776;</span> Pages</a>
+<a href="#/files"><span class="icon">&#128196;</span> Files</a>
+<a href="#/config"><span class="icon">&#9881;</span> Config</a>
+<a href="#/logs"><span class="icon">&#128203;</span> Access Logs</a>
+<a href="#/sites"><span class="icon">&#127760;</span> Sites</a>
+<a href="#/export"><span class="icon">&#9654;</span> Operations</a>
+</nav>
+</div>
+<div class="main">
+
+<!-- Overview Page -->
+<div class="page-view active" id="page-overview">
+<div class="header"><h2>Overview</h2><p class="subtitle">Site health at a glance</p></div>
+<div class="grid" id="statsGrid"></div>
+<div class="table-wrap">
+<table><thead><tr><th>Title</th><th>Type</th><th>URL</th><th>Words</th></tr></thead>
+<tbody id="overviewTable"></tbody></table>
+</div>
+</div>
+
+<!-- Pages Page -->
+<div class="page-view" id="page-pages">
+<div class="header"><h2>Pages</h2><p class="subtitle">All scanned pages</p></div>
+<div class="toolbar">
+<input type="text" id="pageSearch" placeholder="Search pages...">
+<select id="typeFilter"><option value="">All types</option></select>
+</div>
+<div class="table-wrap">
+<table><thead><tr><th>Title</th><th>Type</th><th>URL</th><th>Words</th><th>Tags</th></tr></thead>
+<tbody id="pagesTable"></tbody></table>
+</div>
+</div>
+
+<!-- Files Page -->
+<div class="page-view" id="page-files">
+<div class="header"><h2>Generated Files</h2><p class="subtitle">Preview output files</p></div>
+<div id="filesList"></div>
+</div>
+
+<!-- Config Page -->
+<div class="page-view" id="page-config">
+<div class="header"><h2>Configuration</h2><p class="subtitle">Current AgentSite config (API keys hidden)</p></div>
+<div class="pre-wrap" id="configContent">Loading...</div>
+</div>
+
+<!-- Logs Page -->
+<div class="page-view" id="page-logs">
+<div class="header"><h2>Access Logs</h2><p class="subtitle">Recent API requests</p></div>
+<div class="grid" id="logStats"></div>
+<div class="table-wrap" style="margin-top:16px">
+<div class="log-entry" style="font-weight:600;background:#f9f9f9">
+<span>Timestamp</span><span>Method</span><span>Path</span><span>Status</span><span>Time</span>
+</div>
+<div id="logEntries"></div>
+</div>
+</div>
+
+<!-- Sites Page -->
+<div class="page-view" id="page-sites">
+<div class="header"><h2>Sites</h2><p class="subtitle">Multi-site management</p></div>
+<div id="sitesContent">
+<div class="card"><p>Configure multiple sites in your <code>agentsite.config.yaml</code> using the <code>sites</code> array.</p></div>
+</div>
+</div>
+
+<!-- Export/Operations Page -->
+<div class="page-view" id="page-export">
+<div class="header"><h2>Operations</h2><p class="subtitle">Trigger scan and generation tasks</p></div>
+<div class="grid">
+<div class="card">
+<h3>Re-scan Site</h3>
+<p style="font-size:13px;color:#666;margin-bottom:12px">Crawl the site again and update scan results.</p>
+<button id="btnRescan" style="padding:8px 20px;background:#0066cc;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:13px">Start Rescan</button>
+<div id="rescanStatus" style="margin-top:8px;font-size:12px;color:#666"></div>
+</div>
+<div class="card">
+<h3>Regenerate Files</h3>
+<p style="font-size:13px;color:#666;margin-bottom:12px">Regenerate all output files from scan results.</p>
+<button id="btnRegenerate" style="padding:8px 20px;background:#388e3c;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:13px">Regenerate</button>
+<div id="regenStatus" style="margin-top:8px;font-size:12px;color:#666"></div>
+</div>
+</div>
+</div>
+
+</div>
+<script>
+// Router
+var allPages=[];
+function navigate(){
+  var hash=location.hash||'#/';
+  var route=hash.replace('#','');
+  document.querySelectorAll('.page-view').forEach(function(el){el.classList.remove('active')});
+  document.querySelectorAll('.sidebar a').forEach(function(el){el.classList.remove('active')});
+  var pageMap={'/':"page-overview",'/pages':"page-pages",'/files':"page-files",'/config':"page-config",'/logs':"page-logs",'/sites':"page-sites",'/export':"page-export"};
+  var pageId=pageMap[route]||'page-overview';
+  var el=document.getElementById(pageId);
+  if(el)el.classList.add('active');
+  var link=document.querySelector('.sidebar a[href="'+hash+'"]');
+  if(link)link.classList.add('active');
+  if(route==='/logs')loadLogs();
+  if(route==='/files')loadFiles();
+  if(route==='/config')loadConfig();
+}
+window.addEventListener('hashchange',navigate);
+
+// Load overview + stats
+function loadOverview(){
+  fetch('/api/stats').then(function(r){return r.json()}).then(function(s){
+    var g=document.getElementById('statsGrid');
+    g.innerHTML='<div class="card"><h3>Total Pages</h3><div class="stat">'+s.totalPages+'</div></div>'
+      +'<div class="card"><h3>Total Words</h3><div class="stat">'+s.totalWords.toLocaleString()+'</div></div>'
+      +'<div class="card"><h3>Docs</h3><div class="stat">'+(s.pageTypes.docs||0)+'</div></div>'
+      +'<div class="card"><h3>FAQ</h3><div class="stat">'+(s.pageTypes.faq||0)+'</div></div>'
+      +'<div class="card"><h3>Blog</h3><div class="stat">'+(s.pageTypes.blog||0)+'</div></div>'
+      +'<div class="card"><h3>Products</h3><div class="stat">'+(s.pageTypes.product||0)+'</div></div>';
+  });
+  fetch('/api/pages-data').then(function(r){return r.json()}).then(function(d){
+    allPages=d.pages||[];
+    renderOverviewTable(allPages.slice(0,20));
+    renderPagesTable(allPages);
+    populateTypeFilter(allPages);
+  });
+}
+
+function renderOverviewTable(pages){
+  var tb=document.getElementById('overviewTable');
+  tb.innerHTML=pages.map(function(p){
+    return '<tr><td>'+esc(p.title)+'</td><td><span class="badge badge-'+p.type+'">'+p.type+'</span></td><td style="font-size:12px;color:#666">'+esc(p.url)+'</td><td>'+p.wordCount+'</td></tr>';
+  }).join('');
+}
+
+// Pages
+function renderPagesTable(pages){
+  var tb=document.getElementById('pagesTable');
+  tb.innerHTML=pages.map(function(p){
+    var tags=(p.tags||[]).join(', ');
+    return '<tr><td>'+esc(p.title)+'</td><td><span class="badge badge-'+p.type+'">'+p.type+'</span></td><td style="font-size:12px;color:#666">'+esc(p.url)+'</td><td>'+p.wordCount+'</td><td style="font-size:11px;color:#888">'+esc(tags)+'</td></tr>';
+  }).join('');
+}
+
+function populateTypeFilter(pages){
+  var types={};pages.forEach(function(p){types[p.type]=1});
+  var sel=document.getElementById('typeFilter');
+  Object.keys(types).sort().forEach(function(t){
+    var o=document.createElement('option');o.value=t;o.textContent=t;sel.appendChild(o);
+  });
+}
+
+document.getElementById('pageSearch').addEventListener('input',filterPages);
+document.getElementById('typeFilter').addEventListener('change',filterPages);
+function filterPages(){
+  var q=document.getElementById('pageSearch').value.toLowerCase();
+  var t=document.getElementById('typeFilter').value;
+  var filtered=allPages.filter(function(p){
+    if(t&&p.type!==t)return false;
+    if(q&&p.title.toLowerCase().indexOf(q)===-1&&p.url.toLowerCase().indexOf(q)===-1)return false;
+    return true;
+  });
+  renderPagesTable(filtered);
+}
+
+// Files
+function loadFiles(){
+  fetch('/api/files').then(function(r){return r.json()}).then(function(d){
+    var container=document.getElementById('filesList');
+    container.innerHTML=d.files.map(function(f){
+      var preview=f.content?f.content.substring(0,2000):'';
+      return '<div class="file-card"><div class="file-header" onclick="this.parentElement.classList.toggle(\\'open\\')"><span>'+esc(f.name)+'</span><span style="color:#888">'+formatSize(f.size)+'</span></div><div class="file-body"><pre class="pre-wrap">'+esc(preview)+(f.size>2000?'\\n...truncated':'')+'</pre></div></div>';
+    }).join('');
+  });
+}
+
+// Config
+function loadConfig(){
+  fetch('/api/config').then(function(r){return r.json()}).then(function(c){
+    document.getElementById('configContent').textContent=JSON.stringify(c,null,2);
+  });
+}
+
+// Logs
+function loadLogs(){
+  fetch('/api/access-log?limit=200').then(function(r){return r.json()}).then(function(d){
+    var entries=d.entries||[];
+    // Stats
+    var total=entries.length;
+    var ok=entries.filter(function(e){return e.statusCode<400}).length;
+    var avgTime=total?Math.round(entries.reduce(function(s,e){return s+e.responseTimeMs},0)/total):0;
+    document.getElementById('logStats').innerHTML=
+      '<div class="card"><h3>Recent Requests</h3><div class="stat">'+total+'</div></div>'
+      +'<div class="card"><h3>Success Rate</h3><div class="stat">'+(total?Math.round(ok/total*100):0)+'%</div></div>'
+      +'<div class="card"><h3>Avg Response</h3><div class="stat">'+avgTime+'ms</div></div>';
+    // Entries
+    var container=document.getElementById('logEntries');
+    container.innerHTML=entries.slice(0,100).map(function(e){
+      var cls=e.statusCode<400?'status-2xx':e.statusCode<500?'status-4xx':'status-5xx';
+      return '<div class="log-entry"><span>'+new Date(e.timestamp).toLocaleString()+'</span><span><b>'+e.method+'</b></span><span style="color:#666">'+esc(e.path+(e.query?'?'+e.query:''))+'</span><span class="'+cls+'">'+e.statusCode+'</span><span>'+e.responseTimeMs+'ms</span></div>';
+    }).join('');
+  });
+}
+
+// Operations
+document.getElementById('btnRescan').addEventListener('click',function(){
+  var btn=this;btn.disabled=true;btn.textContent='Scanning...';
+  document.getElementById('rescanStatus').textContent='Running...';
+  fetch('/api/rescan',{method:'POST'}).then(function(r){return r.json()}).then(function(d){
+    document.getElementById('rescanStatus').textContent=d.message||'Done';
+    btn.disabled=false;btn.textContent='Start Rescan';
+    loadOverview();
+  }).catch(function(e){
+    document.getElementById('rescanStatus').textContent='Error: '+e.message;
+    btn.disabled=false;btn.textContent='Start Rescan';
+  });
+});
+document.getElementById('btnRegenerate').addEventListener('click',function(){
+  var btn=this;btn.disabled=true;btn.textContent='Generating...';
+  document.getElementById('regenStatus').textContent='Running...';
+  fetch('/api/regenerate',{method:'POST'}).then(function(r){return r.json()}).then(function(d){
+    document.getElementById('regenStatus').textContent=d.message||'Done';
+    btn.disabled=false;btn.textContent='Regenerate';
+  }).catch(function(e){
+    document.getElementById('regenStatus').textContent='Error: '+e.message;
+    btn.disabled=false;btn.textContent='Regenerate';
+  });
+});
+
+// Utils
+function esc(s){if(!s)return '';return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;')}
+function formatSize(b){if(b<1024)return b+'B';if(b<1048576)return (b/1024).toFixed(1)+'KB';return (b/1048576).toFixed(1)+'MB'}
+
+// Init
+loadOverview();
+navigate();
+</script>
+</body>
+</html>`;
+
+// src/server/access-log.ts
+import { appendFileSync, readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+var AccessLogger = class {
+  logPath;
+  constructor(outDir) {
+    this.logPath = `${outDir}/access-log.jsonl`;
+  }
+  log(entry) {
+    appendFileSync(this.logPath, JSON.stringify(entry) + "\n", "utf-8");
+  }
+  getRecent(limit = 100) {
+    if (!existsSync3(this.logPath)) return [];
+    const lines = readFileSync2(this.logPath, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+    return lines.slice(-limit).reverse().map((l) => JSON.parse(l));
+  }
+  register(app) {
+    app.addHook("onResponse", async (request, reply) => {
+      const entry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        method: request.method,
+        path: request.url.split("?")[0],
+        query: request.url.includes("?") ? request.url.split("?")[1] : "",
+        ip: request.ip,
+        userAgent: request.headers["user-agent"] ?? "",
+        statusCode: reply.statusCode,
+        responseTimeMs: Math.round(reply.elapsedTime)
+      };
+      this.log(entry);
+    });
+  }
+};
+
+// src/server/routes/search.ts
+function registerSearchRoute(app, data, searchIndex) {
+  app.get(
+    "/api/search",
+    async (req) => {
+      const q = (req.query.q ?? "").toLowerCase().trim();
+      const page = Math.max(1, parseInt(req.query.page ?? "1", 10));
+      const limit = Math.min(50, Math.max(1, parseInt(req.query.limit ?? "10", 10)));
+      if (!q) return { ok: true, data: [], total: 0, page };
+      const words = q.split(/\W+/).filter((w) => w.length > 2);
+      const scoreMap = /* @__PURE__ */ new Map();
+      for (const word of words) {
+        const matches = searchIndex.get(word);
+        if (matches) {
+          for (const idx of matches) {
+            scoreMap.set(idx, (scoreMap.get(idx) ?? 0) + 1);
+          }
+        }
+      }
+      const sorted = [...scoreMap.entries()].sort((a, b) => b[1] - a[1]);
+      const total = sorted.length;
+      const start = (page - 1) * limit;
+      const results = sorted.slice(start, start + limit).map(([idx]) => data.pages[idx]);
+      return { ok: true, data: results, total, page };
+    }
+  );
+}
+
+// src/server/routes/pages.ts
+function registerPagesRoute(app, data, config) {
+  app.get("/api/pages/:id", async (req, reply) => {
+    const page = data.pages.find((p) => urlToId(p.url) === req.params.id);
+    if (!page) {
+      reply.code(404);
+      return { ok: false, error: "Page not found" };
+    }
+    return { ok: true, data: filterPageContent(page, config) };
+  });
+}
+
+// src/server/routes/faq.ts
+function registerFaqRoute(app, data) {
+  app.get("/api/faq", async (req) => {
+    let items = data.faq;
+    const category = req.query.category;
+    if (category) {
+      items = items.filter((f) => f.category?.toLowerCase() === category.toLowerCase());
+    }
+    return { ok: true, data: items, total: items.length };
+  });
+}
+
+// src/server/routes/products.ts
+function registerProductsRoute(app, data) {
+  app.get("/api/products", async () => {
+    return { ok: true, data: data.products, total: data.products.length };
+  });
+}
+
+// src/server/routes/docs.ts
+function registerDocsRoute(app, data) {
+  app.get("/api/docs", async (req) => {
+    let items = data.docs;
+    const section = req.query.section;
+    if (section) {
+      items = items.filter((d) => d.section?.toLowerCase() === section.toLowerCase());
+    }
+    return { ok: true, data: items, total: items.length };
+  });
+}
+
+// src/server/routes/articles.ts
+function registerArticlesRoute(app, data) {
+  app.get(
+    "/api/articles",
+    async (req) => {
+      let items = data.articles;
+      const tag = req.query.tag;
+      if (tag) {
+        items = items.filter((a) => a.tags?.some((t) => t.toLowerCase() === tag.toLowerCase()));
+      }
+      const page = Math.max(1, parseInt(req.query.page ?? "1", 10));
+      const limit = Math.min(50, Math.max(1, parseInt(req.query.limit ?? "10", 10)));
+      const total = items.length;
+      const start = (page - 1) * limit;
+      const paged = items.slice(start, start + limit);
+      return { ok: true, data: paged, total, page };
+    }
+  );
+}
+
+// src/server/routes/pricing.ts
+function registerPricingRoute(app, data) {
+  app.get("/api/pricing", async () => {
+    return { ok: true, data: data.pricing };
+  });
+}
+
+// src/server/routes/changelog.ts
+function registerChangelogRoute(app, data) {
+  app.get("/api/changelog", async () => {
+    return { ok: true, data: data.changelog };
+  });
+}
+
+// src/server/app.ts
+async function createApp(config, data) {
+  const app = Fastify({ logger: false });
+  await app.register(cors, { origin: true });
+  await app.register(rateLimit, {
+    max: config.server.rateLimit.max,
+    timeWindow: config.server.rateLimit.timeWindow
+  });
+  let accessLogger;
+  if (config.server.accessLog) {
+    accessLogger = new AccessLogger(config.output.dir);
+    accessLogger.register(app);
+  }
+  const filteredPages = data.pages.filter((page) => isPageAllowed(page, config));
+  const filteredData = { ...data, pages: filteredPages };
+  const searchIndex = buildSearchIndex(filteredData);
+  app.get("/api/health", async () => ({ ok: true }));
+  app.get("/api/access-log", async (req) => {
+    if (!accessLogger) return { entries: [], message: "Access logging is disabled" };
+    const query = req.query;
+    const limit = parseInt(query.limit, 10) || 100;
+    return { entries: accessLogger.getRecent(limit) };
+  });
+  app.get("/api/stats", async () => {
+    const typeCounts = {};
+    let totalWords = 0;
+    for (const p of filteredData.pages) {
+      typeCounts[p.type] = (typeCounts[p.type] ?? 0) + 1;
+      totalWords += p.wordCount;
+    }
+    return {
+      totalPages: filteredData.pages.length,
+      totalWords,
+      pageTypes: typeCounts,
+      dataFiles: {
+        docs: filteredData.docs.length,
+        faq: filteredData.faq.length,
+        products: filteredData.products.length,
+        articles: filteredData.articles.length,
+        pricing: filteredData.pricing.length,
+        changelog: filteredData.changelog.length
+      }
+    };
+  });
+  app.get("/api/config", async () => {
+    const sanitized = {
+      site: config.site,
+      scan: config.scan,
+      output: config.output,
+      server: { port: config.server.port, rateLimit: config.server.rateLimit, accessLog: config.server.accessLog },
+      access: config.access,
+      llm: config.llm ? { apiUrl: config.llm.apiUrl, model: config.llm.model, apiKey: "***" } : void 0
+    };
+    return sanitized;
+  });
+  app.get("/api/files", async () => {
+    const { readFileSync: readFileSync7, existsSync: existsSync9 } = await import("fs");
+    const outDir = config.output.dir;
+    const files = [];
+    const textFiles = ["llms.txt"];
+    const jsonFiles = ["agent-sitemap.json", "agent-index.json", "data/docs.json", "data/faq.json", "data/products.json", "data/articles.json", "data/pricing.json", "data/changelog.json"];
+    for (const f of textFiles) {
+      const p = `${outDir}/${f}`;
+      if (existsSync9(p)) {
+        const content = readFileSync7(p, "utf-8");
+        files.push({ name: f, size: content.length, content });
+      }
+    }
+    for (const f of jsonFiles) {
+      const p = `${outDir}/${f}`;
+      if (existsSync9(p)) {
+        const content = readFileSync7(p, "utf-8");
+        files.push({ name: f, size: content.length, content });
+      }
+    }
+    return { files };
+  });
+  app.get("/", async (req, reply) => {
+    reply.type("text/html").send(dashboardHtml);
+  });
+  app.get("/api/pages-data", async () => {
+    return {
+      siteUrl: filteredData.pages[0]?.url.split("/").slice(0, 3).join("/") || "",
+      scannedAt: filteredData.pages[0]?.scannedAt || (/* @__PURE__ */ new Date()).toISOString(),
+      totalPages: filteredData.pages.length,
+      pages: filteredData.pages
+    };
+  });
+  if (config.access.allowSearch) {
+    registerSearchRoute(app, filteredData, searchIndex);
+  }
+  registerPagesRoute(app, filteredData, config);
+  registerFaqRoute(app, filteredData);
+  registerProductsRoute(app, filteredData);
+  registerDocsRoute(app, filteredData);
+  registerArticlesRoute(app, filteredData);
+  registerPricingRoute(app, filteredData);
+  registerChangelogRoute(app, filteredData);
+  app.post("/api/rescan", async () => {
+    try {
+      const { runScan } = await import("./scan-QWNB65DB.js");
+      const result = await runScan();
+      return { ok: true, message: `Rescan complete. ${result.totalPages} pages scanned.` };
+    } catch (err) {
+      return { ok: false, message: err.message };
+    }
+  });
+  app.post("/api/regenerate", async () => {
+    try {
+      const { runGenerate } = await import("./generate-V5JMMT4J.js");
+      await runGenerate();
+      return { ok: true, message: "Regeneration complete." };
+    } catch (err) {
+      return { ok: false, message: err.message };
+    }
+  });
+  return app;
+}
+function buildSearchIndex(data) {
+  const index = /* @__PURE__ */ new Map();
+  data.pages.forEach((page, i) => {
+    const text = `${page.title} ${page.summary} ${page.type}`.toLowerCase();
+    const words = text.split(/\W+/).filter((w) => w.length > 2);
+    for (const word of words) {
+      if (!index.has(word)) index.set(word, /* @__PURE__ */ new Set());
+      index.get(word).add(i);
+    }
+  });
+  return index;
+}
+
+// src/commands/serve.ts
+function loadJson(path) {
+  if (!existsSync4(path)) return [];
+  return JSON.parse(readFileSync3(path, "utf-8"));
+}
+function loadSiteData(outDir) {
+  const scanPath = `${outDir}/scan-result.json`;
+  if (!existsSync4(scanPath)) return null;
+  const scanResult = JSON.parse(readFileSync3(scanPath, "utf-8"));
+  const data = {
+    pages: scanResult.pages,
+    docs: loadJson(`${outDir}/data/docs.json`),
+    faq: loadJson(`${outDir}/data/faq.json`),
+    products: loadJson(`${outDir}/data/products.json`),
+    articles: loadJson(`${outDir}/data/articles.json`),
+    pricing: loadJson(`${outDir}/data/pricing.json`),
+    changelog: loadJson(`${outDir}/data/changelog.json`)
+  };
+  return { scanResult, data };
+}
+function registerServeCommand(program2) {
+  program2.command("serve").description("Start the Agent-friendly API server").option("-p, --port <port>", "Port number").action(async (opts) => {
+    const config = loadConfig();
+    const outDir = config.output.dir;
+    const primary = loadSiteData(outDir);
+    const data = primary?.data ?? {
+      pages: [],
+      docs: [],
+      faq: [],
+      products: [],
+      articles: [],
+      pricing: [],
+      changelog: []
+    };
+    if (!primary) {
+      log.warn("No scan data found. Server starting with empty data.");
+      log.warn("Use the Dashboard Operations panel or run `agentsite scan && agentsite generate` to populate.");
+    }
+    const port = parseInt(opts.port, 10) || config.server.port;
+    const app = await createApp(config, data);
+    if (config.resolvedSites.length > 1) {
+      for (const siteEntry of config.resolvedSites) {
+        const slug = toSlug(siteEntry.site.name);
+        const siteOutDir = siteEntry.output.dir;
+        const siteData = loadSiteData(siteOutDir);
+        if (siteData) {
+          app.get(`/api/${slug}/pages-data`, async () => ({
+            siteUrl: siteData.scanResult.siteUrl,
+            scannedAt: siteData.scanResult.scannedAt,
+            totalPages: siteData.scanResult.totalPages,
+            pages: siteData.data.pages
+          }));
+          app.get(`/api/${slug}/search`, async (req) => {
+            const query = req.query;
+            return { site: slug, query: query.q, results: [] };
+          });
+          app.get(`/api/${slug}/docs`, async () => siteData.data.docs);
+          app.get(`/api/${slug}/faq`, async () => siteData.data.faq);
+          app.get(`/api/${slug}/products`, async () => siteData.data.products);
+          app.get(`/api/${slug}/articles`, async () => siteData.data.articles);
+          app.get(`/api/${slug}/pricing`, async () => siteData.data.pricing);
+          app.get(`/api/${slug}/changelog`, async () => siteData.data.changelog);
+        }
+      }
+    }
+    app.get("/api/sites", async () => {
+      return {
+        sites: config.resolvedSites.map((s) => ({
+          name: s.site.name,
+          slug: toSlug(s.site.name),
+          url: s.site.url,
+          description: s.site.description,
+          outDir: s.output.dir
+        }))
+      };
+    });
+    await app.listen({ port, host: "0.0.0.0" });
+    log.success(`API server running at http://localhost:${port}`);
+    log.info("Endpoints:");
+    console.log("  GET /api/health");
+    console.log("  GET /api/search?q=keyword");
+    console.log("  GET /api/pages/:id");
+    console.log("  GET /api/faq");
+    console.log("  GET /api/products");
+    console.log("  GET /api/docs");
+    console.log("  GET /api/articles");
+    console.log("  GET /api/pricing");
+    console.log("  GET /api/changelog");
+    console.log("  GET /api/stats");
+    console.log("  GET /api/config");
+    console.log("  GET /api/files");
+    console.log("  GET /api/access-log");
+    console.log("  GET /api/sites");
+    if (config.resolvedSites.length > 1) {
+      for (const s of config.resolvedSites) {
+        console.log(`  GET /api/${toSlug(s.site.name)}/* (multi-site)`);
+      }
+    }
+  });
+}
+
+// src/commands/update.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+
+// src/change-detection/store.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
+function loadHashes(path) {
+  if (!existsSync5(path)) return {};
+  return JSON.parse(readFileSync4(path, "utf-8"));
+}
+function saveHashes(path, hashes) {
+  writeFileSync2(path, JSON.stringify(hashes, null, 2), "utf-8");
+}
+function findChangedUrls(oldHashes, newHashes) {
+  const changed = [];
+  for (const [url, hash] of Object.entries(newHashes)) {
+    if (oldHashes[url] !== hash) changed.push(url);
+  }
+  return changed;
+}
+
+// src/commands/update.ts
+function registerUpdateCommand(program2) {
+  program2.command("update").description("Incrementally update: re-scan, detect changes, regenerate").action(async () => {
+    const config = loadConfig();
+    const outDir = config.output.dir;
+    const hashPath = `${outDir}/cache/hashes.json`;
+    mkdirSync2(`${outDir}/cache/pages`, { recursive: true });
+    mkdirSync2(`${outDir}/data`, { recursive: true });
+    const oldHashes = loadHashes(hashPath);
+    const sp = spinner("Re-scanning site...");
+    const sitemapUrls = await parseSitemap(config.site.url);
+    const crawled = await crawlSite(config, sitemapUrls, (url, i) => {
+      sp.text = `Scanning (${i})... ${url}`;
+    });
+    sp.succeed(`Scanned ${crawled.length} pages`);
+    const newHashes = {};
+    const pages = [];
+    for (const { url, html } of crawled) {
+      const content = extractContent(html, url);
+      const contentHash = sha256(content.bodyText);
+      newHashes[url] = contentHash;
+      const pageType = classifyPage({
+        url,
+        title: content.title,
+        metaOgType: content.metaOgType,
+        headings: content.headings,
+        bodyText: content.bodyText
+      });
+      pages.push({
+        url,
+        title: content.title,
+        type: pageType,
+        contentHash,
+        summary: content.summary,
+        headings: content.headings,
+        lastModified: content.lastModified,
+        scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        wordCount: content.wordCount,
+        tags: content.tags,
+        version: content.version,
+        author: content.author,
+        publishedAt: content.publishedAt,
+        updatedAt: content.lastModified
+      });
+    }
+    const changed = findChangedUrls(oldHashes, newHashes);
+    if (changed.length === 0) {
+      log.success("No changes detected. Everything is up to date.");
+      return;
+    }
+    log.info(`${changed.length} page(s) changed`);
+    const result = {
+      siteUrl: config.site.url,
+      scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalPages: pages.length,
+      pages
+    };
+    writeFileSync3(`${outDir}/scan-result.json`, JSON.stringify(result, null, 2), "utf-8");
+    const genSp = spinner("Regenerating files...");
+    writeFileSync3(`${outDir}/llms.txt`, generateLlmsTxt(result, config.site.name, config.site.description), "utf-8");
+    writeFileSync3(`${outDir}/agent-sitemap.json`, JSON.stringify(generateAgentSitemap(result), null, 2), "utf-8");
+    writeFileSync3(`${outDir}/agent-index.json`, JSON.stringify(generateAgentIndex(result, config.site.name, config.site.description), null, 2), "utf-8");
+    const { docs, faq, products, articles, pricing, changelog } = await generateStructuredExports(result, outDir, config);
+    writeFileSync3(`${outDir}/data/docs.json`, JSON.stringify(docs, null, 2), "utf-8");
+    writeFileSync3(`${outDir}/data/faq.json`, JSON.stringify(faq, null, 2), "utf-8");
+    writeFileSync3(`${outDir}/data/products.json`, JSON.stringify(products, null, 2), "utf-8");
+    writeFileSync3(`${outDir}/data/articles.json`, JSON.stringify(articles, null, 2), "utf-8");
+    writeFileSync3(`${outDir}/data/pricing.json`, JSON.stringify(pricing, null, 2), "utf-8");
+    writeFileSync3(`${outDir}/data/changelog.json`, JSON.stringify(changelog, null, 2), "utf-8");
+    saveHashes(hashPath, newHashes);
+    genSp.succeed("All files regenerated");
+    log.success(`Update complete. ${changed.length} page(s) updated.`);
+  });
+}
+
+// src/commands/mcp.ts
+import { existsSync as existsSync8 } from "fs";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+function loadData(outDir) {
+  const loadJson2 = (path) => {
+    if (!existsSync7(path)) return [];
+    return JSON.parse(readFileSync6(path, "utf-8"));
+  };
+  const scanResult = JSON.parse(readFileSync6(`${outDir}/scan-result.json`, "utf-8"));
+  return {
+    scanResult,
+    docs: loadJson2(`${outDir}/data/docs.json`),
+    faq: loadJson2(`${outDir}/data/faq.json`),
+    products: loadJson2(`${outDir}/data/products.json`),
+    articles: loadJson2(`${outDir}/data/articles.json`),
+    pricing: loadJson2(`${outDir}/data/pricing.json`),
+    changelog: loadJson2(`${outDir}/data/changelog.json`)
+  };
+}
+function buildSearchIndex2(pages) {
+  const index = /* @__PURE__ */ new Map();
+  pages.forEach((page, i) => {
+    const text = `${page.title} ${page.summary} ${page.type}`.toLowerCase();
+    const words = text.split(/\W+/).filter((w) => w.length > 2);
+    for (const word of words) {
+      if (!index.has(word)) index.set(word, /* @__PURE__ */ new Set());
+      index.get(word).add(i);
+    }
+  });
+  return index;
+}
+async function startMcpServer(outDir) {
+  const data = loadData(outDir);
+  const searchIndex = buildSearchIndex2(data.scanResult.pages);
+  const server = new McpServer({
+    name: "agentsite",
+    version: "1.0.0"
+  });
+  server.tool(
+    "search",
+    "Search site content by keyword",
+    { query: z.string().describe("Search keyword"), limit: z.number().optional().describe("Max results (default 10)") },
+    async ({ query, limit }) => {
+      const max = limit ?? 10;
+      const words = query.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
+      const scoreMap = /* @__PURE__ */ new Map();
+      for (const word of words) {
+        const matches = searchIndex.get(word);
+        if (matches) {
+          for (const idx of matches) {
+            scoreMap.set(idx, (scoreMap.get(idx) ?? 0) + 1);
+          }
+        }
+      }
+      const sorted = [...scoreMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, max).map(([idx]) => {
+        const p = data.scanResult.pages[idx];
+        return { url: p.url, title: p.title, type: p.type, summary: p.summary };
+      });
+      return { content: [{ type: "text", text: JSON.stringify(sorted, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_page",
+    "Get detailed info about a specific page by URL",
+    { url: z.string().describe("Page URL") },
+    async ({ url }) => {
+      const page = data.scanResult.pages.find((p) => p.url === url);
+      if (!page) {
+        return { content: [{ type: "text", text: "Page not found" }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(page, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_pages",
+    "List all pages with optional type filter",
+    { type: z.string().optional().describe("Filter by page type: docs, faq, blog, product, pricing, about, contact, changelog") },
+    async ({ type }) => {
+      let pages = data.scanResult.pages;
+      if (type) {
+        pages = pages.filter((p) => p.type === type);
+      }
+      const summary = pages.map((p) => ({ url: p.url, title: p.title, type: p.type }));
+      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_faq",
+    "List FAQ entries with optional category filter",
+    { category: z.string().optional().describe("Filter by category") },
+    async ({ category }) => {
+      let items = data.faq;
+      if (category) {
+        items = items.filter((f) => f.category.toLowerCase() === category.toLowerCase());
+      }
+      return { content: [{ type: "text", text: JSON.stringify(items, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_docs",
+    "List documentation entries with optional section filter",
+    { section: z.string().optional().describe("Filter by section") },
+    async ({ section }) => {
+      let items = data.docs;
+      if (section) {
+        items = items.filter((d) => d.section.toLowerCase() === section.toLowerCase());
+      }
+      return { content: [{ type: "text", text: JSON.stringify(items, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_products",
+    "List all product entries",
+    {},
+    async () => {
+      return { content: [{ type: "text", text: JSON.stringify(data.products, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_articles",
+    "List blog/article entries with optional tag filter",
+    { tag: z.string().optional().describe("Filter by tag") },
+    async ({ tag }) => {
+      let items = data.articles;
+      if (tag) {
+        items = items.filter((a) => a.tags.some((t) => t.toLowerCase() === tag.toLowerCase()));
+      }
+      return { content: [{ type: "text", text: JSON.stringify(items, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_pricing",
+    "List pricing/plan entries",
+    {},
+    async () => {
+      return { content: [{ type: "text", text: JSON.stringify(data.pricing, null, 2) }] };
+    }
+  );
+  server.tool(
+    "list_changelog",
+    "List changelog/release entries",
+    { version: z.string().optional().describe("Filter by version") },
+    async ({ version }) => {
+      let items = data.changelog;
+      if (version) {
+        items = items.filter((c) => c.version.toLowerCase().includes(version.toLowerCase()));
+      }
+      return { content: [{ type: "text", text: JSON.stringify(items, null, 2) }] };
+    }
+  );
+  server.tool(
+    "get_config",
+    "Get site configuration summary (API keys hidden)",
+    {},
+    async () => {
+      const configPath = `${outDir}/../agentsite.config.yaml`;
+      let configSummary = { note: "Config file not found at expected location" };
+      if (existsSync7(configPath)) {
+        const yaml3 = await import("js-yaml");
+        const raw = readFileSync6(configPath, "utf-8");
+        const parsed = yaml3.load(raw);
+        if (parsed.llm && typeof parsed.llm === "object") {
+          parsed.llm.apiKey = "***";
+        }
+        configSummary = parsed;
+      }
+      return { content: [{ type: "text", text: JSON.stringify(configSummary, null, 2) }] };
+    }
+  );
+  server.tool(
+    "site_overview",
+    "Get a high-level overview of the site: name, description, page counts by type",
+    {},
+    async () => {
+      const typeCounts = {};
+      for (const p of data.scanResult.pages) {
+        typeCounts[p.type] = (typeCounts[p.type] ?? 0) + 1;
+      }
+      const overview = {
+        totalPages: data.scanResult.totalPages,
+        scannedAt: data.scanResult.scannedAt,
+        pageTypes: typeCounts,
+        dataFiles: {
+          docs: data.docs.length,
+          faq: data.faq.length,
+          products: data.products.length,
+          articles: data.articles.length,
+          pricing: data.pricing.length,
+          changelog: data.changelog.length
+        }
+      };
+      return { content: [{ type: "text", text: JSON.stringify(overview, null, 2) }] };
+    }
+  );
+  const llmsPath = `${outDir}/llms.txt`;
+  if (existsSync7(llmsPath)) {
+    server.resource(
+      "llms-txt",
+      "file:///llms.txt",
+      { description: "LLM-friendly site overview in llms.txt format", mimeType: "text/plain" },
+      async () => ({
+        contents: [{ uri: "file:///llms.txt", text: readFileSync6(llmsPath, "utf-8"), mimeType: "text/plain" }]
+      })
+    );
+  }
+  const indexPath = `${outDir}/agent-index.json`;
+  if (existsSync7(indexPath)) {
+    server.resource(
+      "agent-index",
+      "file:///agent-index.json",
+      { description: "Agent index with site metadata and API endpoints", mimeType: "application/json" },
+      async () => ({
+        contents: [{ uri: "file:///agent-index.json", text: readFileSync6(indexPath, "utf-8"), mimeType: "application/json" }]
+      })
+    );
+  }
+  const sitemapPath = `${outDir}/agent-sitemap.json`;
+  if (existsSync7(sitemapPath)) {
+    server.resource(
+      "agent-sitemap",
+      "file:///agent-sitemap.json",
+      { description: "Machine-readable sitemap with page metadata", mimeType: "application/json" },
+      async () => ({
+        contents: [{ uri: "file:///agent-sitemap.json", text: readFileSync6(sitemapPath, "utf-8"), mimeType: "application/json" }]
+      })
+    );
+  }
+  const dataFiles = ["docs", "faq", "products", "articles", "pricing", "changelog"];
+  for (const name of dataFiles) {
+    const dataPath = `${outDir}/data/${name}.json`;
+    if (existsSync7(dataPath)) {
+      server.resource(
+        `data-${name}`,
+        `file:///data/${name}.json`,
+        { description: `Structured ${name} data`, mimeType: "application/json" },
+        async () => ({
+          contents: [{ uri: `file:///data/${name}.json`, text: readFileSync6(dataPath, "utf-8"), mimeType: "application/json" }]
+        })
+      );
+    }
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/mcp.ts
+function registerMcpCommand(program2) {
+  program2.command("mcp").description("Start MCP (Model Context Protocol) server over stdio").action(async () => {
+    const config = loadConfig();
+    const outDir = config.output.dir;
+    if (!existsSync8(`${outDir}/scan-result.json`)) {
+      log.error("No data found. Run `agentsite scan` and `agentsite generate` first.");
+      process.exit(1);
+    }
+    await startMcpServer(outDir);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("agentsite").description("Make any website Agent-friendly").version("1.0.0");
+registerInitCommand(program);
+registerScanCommand(program);
+registerGenerateCommand(program);
+registerServeCommand(program);
+registerUpdateCommand(program);
+registerMcpCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map