@corsenai/corsen-context-cli 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Corsen AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# @corsenai/corsen-context-cli
+
+Command-line tools for **[Corsen Context](https://github.com/CorsenAI/corsen-context)** — scaffold your integration, generate `llms.txt` from a live site, and check if your site is AI-ready.
+
+```bash
+# Detect your framework and scaffold config + route files
+npx @corsenai/corsen-context-cli init
+
+# Generate llms.txt (and llms-full.txt) from a live site
+npx @corsenai/corsen-context-cli generate --url https://example.com --full
+
+# Check whether a site is AI-ready
+npx @corsenai/corsen-context-cli doctor --url https://example.com
+```
+
+The `doctor` command checks HTTPS, `llms.txt`, `sitemap.xml`, the robots.txt MCP reference, and MCP endpoint availability.
+
+- **Full docs:** https://github.com/CorsenAI/corsen-context#readme
+- **License:** MIT

package/dist/index.js

@@ -0,0 +1,706 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/init.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function detectFramework(cwd) {
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "wp-config.php")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "wp-content"))) {
+    return { framework: "wordpress", label: "WordPress" };
+  }
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "hugo.toml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "hugo.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "config.toml"))) {
+    return { framework: "hugo", label: "Hugo" };
+  }
+  const pkgPath = (0, import_node_path.join)(cwd, "package.json");
+  if ((0, import_node_fs.existsSync)(pkgPath)) {
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps["next"]) {
+      if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "app")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "src", "app"))) {
+        return { framework: "nextjs-app", label: "Next.js (App Router)" };
+      }
+      return { framework: "nextjs-pages", label: "Next.js (Pages Router)" };
+    }
+    if (allDeps["astro"]) return { framework: "astro", label: "Astro" };
+    if (allDeps["express"]) return { framework: "express", label: "Express" };
+  }
+  if ((0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "index.html"))) {
+    return { framework: "static", label: "Static Site" };
+  }
+  return { framework: "unknown", label: "Unknown" };
+}
+function writeIfNotExists(filePath, content) {
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    console.log(`  Skipped: ${filePath} (already exists)`);
+    return false;
+  }
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(filePath), { recursive: true });
+  (0, import_node_fs.writeFileSync)(filePath, content, "utf-8");
+  console.log(`  Created: ${filePath}`);
+  return true;
+}
+var CONFIG_TEMPLATE = `/** @type {import('@corsenai/corsen-context').CorsenContextConfig} */
+export default {
+  siteUrl: 'https://your-site.com',
+  siteName: 'Your Site Name',
+  description: 'Short description for AI agents.',
+
+  static: {
+    generateLlmsTxt: true,
+    includeFullContent: true,
+  },
+
+  mcp: {
+    enabled: true,
+    endpoint: '/v1/mcp',
+    tools: ['search_site', 'get_page_content', 'list_content', 'get_sitemap'],
+  },
+
+  content: {
+    postTypes: ['post', 'page'],
+    excludePaths: ['/admin', '/cart', '/checkout'],
+    maxPages: 500,
+  },
+
+  security: {
+    rateLimit: 100,
+    burstLimit: 10,
+    allowedOrigins: [],
+    // Only trust X-Forwarded-For / X-Real-IP when behind a proxy you control.
+    trustProxy: false,
+  },
+
+  cache: {
+    enabled: true,
+    ttl: 3600,
+    driver: 'memory',
+  },
+
+  credit: true,
+};
+`;
+var NEXTJS_APP_PROVIDER = `import type { ContentProvider } from '@corsenai/corsen-context';
+
+/**
+ * Implement your content provider here.
+ * This tells Corsen Context how to access your site's pages.
+ *
+ * Replace the stub methods below with real data from your CMS,
+ * database, filesystem, or API.
+ */
+export const siteProvider: ContentProvider = {
+  async getPages() {
+    // Return all public pages with metadata.
+    // Example:
+    // return [
+    //   { url: 'https://your-site.com/', title: 'Home', description: 'Welcome', type: 'page' },
+    //   { url: 'https://your-site.com/blog/hello', title: 'Hello', description: '...', type: 'post' },
+    // ];
+    return [];
+  },
+
+  async getPageContent(url) {
+    // Return full markdown content for a given URL.
+    // Example:
+    // return { url, title: 'Page', description: '...', markdown: '# Page\\n\\nContent', metadata: {} };
+    return null;
+  },
+
+  async searchContent(query, limit) {
+    // Return search results matching the query.
+    // Example:
+    // return [{ url: '...', title: '...', description: '...', snippet: '...', score: 1 }];
+    return [];
+  },
+};
+`;
+var NEXTJS_APP_MCP_ROUTE = `import { createMCPHandler } from '@corsenai/corsen-context-nextjs';
+import { siteProvider } from '@/lib/corsen-provider';
+
+const config = {
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'https://your-site.com',
+};
+
+const { POST, OPTIONS } = createMCPHandler(config, siteProvider);
+export { POST, OPTIONS };
+`;
+var NEXTJS_APP_SSE_ROUTE = `import { createSSEHandler } from '@corsenai/corsen-context-nextjs';
+import { siteProvider } from '@/lib/corsen-provider';
+
+const config = {
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'https://your-site.com',
+};
+
+// Passing the provider shares auth + rate-limit state with the MCP route.
+export const GET = createSSEHandler(config, siteProvider);
+`;
+var NEXTJS_APP_LLMS_ROUTE = `import { createLlmsTxtHandler } from '@corsenai/corsen-context-nextjs';
+import { siteProvider } from '@/lib/corsen-provider';
+
+const config = {
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'https://your-site.com',
+};
+
+export const GET = createLlmsTxtHandler(config, siteProvider);
+`;
+var NEXTJS_APP_LLMS_FULL_ROUTE = `import { createLlmsFullTxtHandler } from '@corsenai/corsen-context-nextjs';
+import { siteProvider } from '@/lib/corsen-provider';
+
+const config = {
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'https://your-site.com',
+};
+
+export const GET = createLlmsFullTxtHandler(config, siteProvider);
+`;
+var NEXTJS_PAGES_MCP_ROUTE = `import type { NextApiRequest, NextApiResponse } from 'next';
+import { CorsenContext } from '@corsenai/corsen-context';
+// import { siteProvider } from '@/lib/corsen-provider';
+
+const config = {
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'https://your-site.com',
+};
+
+// Replace with your provider
+const provider = {
+  async getPages() { return []; },
+  async getPageContent(url) { return null; },
+  async searchContent(query, limit) { return []; },
+};
+
+const cc = new CorsenContext(config, provider);
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  if (req.method === 'OPTIONS') {
+    res.status(204).end();
+    return;
+  }
+
+  if (req.method !== 'POST') {
+    res.status(405).json({ error: 'Method not allowed' });
+    return;
+  }
+
+  const server = cc.createMCPServer();
+
+  // Security headers
+  for (const [key, value] of Object.entries(server.getSecurityHeaders())) {
+    res.setHeader(key, value);
+  }
+
+  // Use the socket address by default. Only trust X-Forwarded-For behind a
+  // proxy you control, otherwise it is spoofable and defeats rate limiting.
+  const clientIp = req.socket.remoteAddress || 'unknown';
+
+  // Forward the API key so CORSEN_CONTEXT_API_KEY auth works.
+  const apiKey =
+    (req.headers['x-mcp-key'] as string) ||
+    (req.headers['authorization'] as string)?.replace('Bearer ', '') ||
+    undefined;
+
+  const rateLimit = await server.checkRateLimit(clientIp, apiKey);
+  for (const [key, value] of Object.entries(rateLimit.headers)) {
+    res.setHeader(key, value);
+  }
+  if (!rateLimit.allowed) {
+    res.status(429).json({ jsonrpc: '2.0', error: { code: -32000, message: 'Rate limit exceeded' }, id: null });
+    return;
+  }
+
+  // skipRateLimit: we already ran the limiter above (don't double-count).
+  const result = await server.handleRequest(req.body, clientIp, apiKey, { skipRateLimit: true });
+
+  // Notification (no id) \u2014 204 No Content
+  if (result === null) {
+    res.status(204).end();
+    return;
+  }
+
+  res.status(200).json(result);
+}
+`;
+var NEXTJS_PAGES_LLMS_ROUTE = `import type { NextApiRequest, NextApiResponse } from 'next';
+import { CorsenContext } from '@corsenai/corsen-context';
+
+const config = {
+  siteUrl: process.env.NEXT_PUBLIC_SITE_URL || 'https://your-site.com',
+};
+
+const provider = {
+  async getPages() { return []; },
+  async getPageContent(url) { return null; },
+  async searchContent(query, limit) { return []; },
+};
+
+const cc = new CorsenContext(config, provider);
+
+export default async function handler(_req: NextApiRequest, res: NextApiResponse) {
+  const text = await cc.generateLlmsTxt();
+  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+  res.setHeader('Cache-Control', 'public, max-age=3600, s-maxage=3600');
+  res.status(200).send(text);
+}
+`;
+var EXPRESS_MIDDLEWARE = `import express from 'express';
+import { CorsenContext } from '@corsenai/corsen-context';
+// import config from './corsen-context.config.mjs';
+
+const config = {
+  siteUrl: 'https://your-site.com',
+};
+
+// Replace with your content provider
+const provider = {
+  async getPages() { return []; },
+  async getPageContent(url) { return null; },
+  async searchContent(query, limit) { return []; },
+};
+
+const cc = new CorsenContext(config, provider);
+
+/**
+ * Mount these routes in your Express app:
+ *   import corsenContextRoutes from './corsen-context.routes.js';
+ *   corsenContextRoutes(app);
+ */
+export default function corsenContextRoutes(app) {
+  // Ensure JSON body parsing is available for the MCP endpoint.
+  app.use('/v1/mcp', express.json());
+
+  // Serve /llms.txt
+  app.get('/llms.txt', async (_req, res) => {
+    const text = await cc.generateLlmsTxt();
+    res.type('text/plain').set('Cache-Control', 'public, max-age=3600').send(text);
+  });
+
+  // Serve /llms-full.txt
+  app.get('/llms-full.txt', async (_req, res) => {
+    const text = await cc.generateLlmsFullTxt();
+    res.type('text/plain').set('Cache-Control', 'public, max-age=3600').send(text);
+  });
+
+  // MCP endpoint
+  app.post('/v1/mcp', async (req, res) => {
+    const server = cc.createMCPServer();
+
+    // Security headers
+    for (const [key, value] of Object.entries(server.getSecurityHeaders())) {
+      res.set(key, value);
+    }
+
+    // Use the socket address by default. Only trust X-Forwarded-For behind a
+    // proxy you control, otherwise it is spoofable and defeats rate limiting.
+    const clientIp = req.socket.remoteAddress || 'unknown';
+
+    // Forward the API key so CORSEN_CONTEXT_API_KEY auth works.
+    const apiKey = req.headers['x-mcp-key']?.toString()
+      || req.headers['authorization']?.toString().replace('Bearer ', '')
+      || undefined;
+
+    const rateLimit = await server.checkRateLimit(clientIp, apiKey);
+    for (const [key, value] of Object.entries(rateLimit.headers)) {
+      res.set(key, value);
+    }
+    if (!rateLimit.allowed) {
+      return res.status(429).json({
+        jsonrpc: '2.0', error: { code: -32000, message: 'Rate limit exceeded' }, id: null,
+      });
+    }
+
+    // skipRateLimit: we already ran the limiter above (don't double-count).
+    const result = await server.handleRequest(req.body, clientIp, apiKey, { skipRateLimit: true });
+
+    // Notification \u2014 no response
+    if (result === null) {
+      return res.status(204).end();
+    }
+
+    res.json(result);
+  });
+}
+`;
+var ASTRO_PROVIDER = `import type { ContentProvider } from '@corsenai/corsen-context';
+
+/**
+ * Implement your content provider here \u2014 tell Corsen Context how to read your
+ * pages. Replace the stubs with real data from your content collections or CMS.
+ */
+export const siteProvider: ContentProvider = {
+  async getPages() {
+    return [];
+  },
+  async getPageContent(url) {
+    return null;
+  },
+  async searchContent(query, limit) {
+    return [];
+  },
+};
+`;
+var ASTRO_MCP_ENDPOINT = `import { createMCPHandler } from '@corsenai/corsen-context-astro';
+import { siteProvider } from '../../lib/corsen-provider';
+
+// The Astro adapter handles auth, rate limiting (by clientAddress), CORS, and
+// security headers. It reads the real client IP from Astro's clientAddress.
+export const { POST, OPTIONS } = createMCPHandler(
+  { siteUrl: import.meta.env.SITE ?? 'https://your-site.com' },
+  siteProvider,
+);
+`;
+var ASTRO_LLMS_ENDPOINT = `import { createLlmsTxtHandler } from '@corsenai/corsen-context-astro';
+import { siteProvider } from '../lib/corsen-provider';
+
+export const GET = createLlmsTxtHandler(
+  { siteUrl: import.meta.env.SITE ?? 'https://your-site.com' },
+  siteProvider,
+);
+`;
+function scaffoldNextjsApp(cwd) {
+  const appDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "src", "app")) ? (0, import_node_path.join)(cwd, "src") : cwd;
+  const libDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "src")) ? (0, import_node_path.join)(cwd, "src", "lib") : (0, import_node_path.join)(cwd, "lib");
+  writeIfNotExists((0, import_node_path.join)(libDir, "corsen-provider.ts"), NEXTJS_APP_PROVIDER);
+  writeIfNotExists((0, import_node_path.join)(appDir, "app", "api", "mcp", "route.ts"), NEXTJS_APP_MCP_ROUTE);
+  writeIfNotExists((0, import_node_path.join)(appDir, "app", "api", "mcp", "sse", "route.ts"), NEXTJS_APP_SSE_ROUTE);
+  writeIfNotExists((0, import_node_path.join)(appDir, "app", "api", "corsen-context", "llms-txt", "route.ts"), NEXTJS_APP_LLMS_ROUTE);
+  writeIfNotExists((0, import_node_path.join)(appDir, "app", "api", "corsen-context", "llms-full-txt", "route.ts"), NEXTJS_APP_LLMS_FULL_ROUTE);
+  console.log("\n  Next steps:");
+  console.log("  1. npm install @corsenai/corsen-context @corsenai/corsen-context-nextjs");
+  console.log("  2. Edit lib/corsen-provider.ts with your content source");
+  console.log("  3. Update siteUrl in the route files or set NEXT_PUBLIC_SITE_URL env var");
+  console.log("  4. Optionally wrap next.config.mjs with withCorsenContext() for /llms.txt rewrites");
+}
+function scaffoldNextjsPages(cwd) {
+  const pagesDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "src", "pages")) ? (0, import_node_path.join)(cwd, "src", "pages") : (0, import_node_path.join)(cwd, "pages");
+  writeIfNotExists((0, import_node_path.join)(pagesDir, "api", "mcp.ts"), NEXTJS_PAGES_MCP_ROUTE);
+  writeIfNotExists((0, import_node_path.join)(pagesDir, "api", "llms-txt.ts"), NEXTJS_PAGES_LLMS_ROUTE);
+  console.log("\n  Next steps:");
+  console.log("  1. npm install @corsenai/corsen-context");
+  console.log("  2. Edit pages/api/mcp.ts \u2014 replace the stub provider");
+  console.log("  3. Set NEXT_PUBLIC_SITE_URL env var");
+  console.log("  4. Add rewrites in next.config.mjs:");
+  console.log('     { source: "/llms.txt", destination: "/api/llms-txt" }');
+}
+function scaffoldExpress(cwd) {
+  const srcDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "src")) ? (0, import_node_path.join)(cwd, "src") : cwd;
+  writeIfNotExists((0, import_node_path.join)(srcDir, "corsen-context.routes.js"), EXPRESS_MIDDLEWARE);
+  console.log("\n  Next steps:");
+  console.log("  1. npm install @corsenai/corsen-context");
+  console.log("  2. Import and mount the routes in your Express app:");
+  console.log('     import corsenContextRoutes from "./corsen-context.routes.js";');
+  console.log("     corsenContextRoutes(app);");
+  console.log("  3. Edit the provider in corsen-context.routes.js");
+}
+function scaffoldAstro(cwd) {
+  const srcDir = (0, import_node_fs.existsSync)((0, import_node_path.join)(cwd, "src")) ? (0, import_node_path.join)(cwd, "src") : cwd;
+  const pagesDir = (0, import_node_path.join)(srcDir, "pages");
+  writeIfNotExists((0, import_node_path.join)(srcDir, "lib", "corsen-provider.ts"), ASTRO_PROVIDER);
+  writeIfNotExists((0, import_node_path.join)(pagesDir, "v1", "mcp.ts"), ASTRO_MCP_ENDPOINT);
+  writeIfNotExists((0, import_node_path.join)(pagesDir, "llms.txt.ts"), ASTRO_LLMS_ENDPOINT);
+  console.log("\n  Next steps:");
+  console.log("  1. npm install @corsenai/corsen-context @corsenai/corsen-context-astro");
+  console.log('  2. Make sure Astro SSR is enabled (output: "server" or "hybrid" in astro.config)');
+  console.log("  3. Edit the provider in src/lib/corsen-provider.ts with your content source");
+}
+function scaffoldStatic(cwd) {
+  console.log("\n  Static site detected. Options:");
+  console.log("  1. Generate llms.txt from your live site:");
+  console.log("     npx @corsenai/corsen-context-cli generate --url https://your-site.com");
+  console.log("  2. Place the generated llms.txt in your site root");
+  console.log("  3. For a dynamic MCP server, deploy a serverless function:");
+  console.log("     - Vercel: create api/mcp.ts");
+  console.log("     - Netlify: create netlify/functions/mcp.ts");
+  console.log("     - Cloudflare Workers: use the core library directly");
+}
+function scaffoldHugo(cwd) {
+  console.log("\n  Hugo detected. Options:");
+  console.log("  1. Generate llms.txt from your live site:");
+  console.log("     npx @corsenai/corsen-context-cli generate --url https://your-site.com");
+  console.log("  2. Place llms.txt in your static/ directory");
+  console.log("  3. For a dynamic MCP server, deploy a serverless function alongside your Hugo site");
+}
+async function init() {
+  const cwd = process.cwd();
+  const { framework, label } = detectFramework(cwd);
+  console.log(`
+  Detected framework: ${label}`);
+  console.log("  Initializing Corsen Context...\n");
+  writeIfNotExists((0, import_node_path.join)(cwd, "corsen-context.config.mjs"), CONFIG_TEMPLATE);
+  switch (framework) {
+    case "nextjs-app":
+      scaffoldNextjsApp(cwd);
+      break;
+    case "nextjs-pages":
+      scaffoldNextjsPages(cwd);
+      break;
+    case "express":
+      scaffoldExpress(cwd);
+      break;
+    case "astro":
+      scaffoldAstro(cwd);
+      break;
+    case "hugo":
+      scaffoldHugo(cwd);
+      break;
+    case "static":
+      scaffoldStatic(cwd);
+      break;
+    case "wordpress":
+      console.log("\n  WordPress detected.");
+      console.log("  Install the Corsen Context plugin from WordPress.org or GitHub:");
+      console.log("  https://github.com/CorsenAI/corsen-context/tree/main/packages/wordpress-plugin");
+      break;
+    default:
+      console.log("\n  Framework not detected. Generic setup:");
+      console.log("  1. npm install @corsenai/corsen-context");
+      console.log("  2. See: https://github.com/CorsenAI/corsen-context#quick-start");
+      break;
+  }
+  console.log("\n  Edit corsen-context.config.mjs to set your siteUrl and options.");
+  console.log('  Run "npx @corsenai/corsen-context-cli doctor --url https://your-site.com" to validate.\n');
+}
+
+// src/generate.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_corsen_context = require("@corsenai/corsen-context");
+function parseArgs(args2) {
+  const result = {};
+  for (let i = 0; i < args2.length; i++) {
+    if ((args2[i] === "--url" || args2[i] === "-u") && args2[i + 1]) {
+      result.url = args2[++i];
+    }
+    if ((args2[i] === "--output" || args2[i] === "-o") && args2[i + 1]) {
+      result.output = args2[++i];
+    }
+    if (args2[i] === "--full") {
+      result.full = true;
+    }
+  }
+  return result;
+}
+async function generate(args2) {
+  const { url, output, full } = parseArgs(args2);
+  if (!url) {
+    console.error("  Error: --url is required");
+    console.error("  Usage: npx corsen-context generate --url https://mysite.com [--full]");
+    process.exit(1);
+  }
+  console.log(`
+  Generating llms.txt for ${url}...`);
+  console.log("  Discovering + fetching pages via sitemap...");
+  const provider = (0, import_corsen_context.createSitemapProvider)(url, { maxPages: 100 });
+  const cc = new import_corsen_context.CorsenContext({ siteUrl: url }, provider);
+  const outputDir = output || process.cwd();
+  console.log("  Generating llms.txt...");
+  const llmsTxt = await cc.generateLlmsTxt();
+  const llmsPath = (0, import_node_path2.join)(outputDir, "llms.txt");
+  (0, import_node_fs2.writeFileSync)(llmsPath, llmsTxt, "utf-8");
+  console.log(`  Written: ${llmsPath}`);
+  if (full) {
+    console.log("  Generating llms-full.txt...");
+    const llmsFull = await cc.generateLlmsFullTxt();
+    const fullPath = (0, import_node_path2.join)(outputDir, "llms-full.txt");
+    (0, import_node_fs2.writeFileSync)(fullPath, llmsFull, "utf-8");
+    console.log(`  Written: ${fullPath}`);
+  }
+  console.log("\n  Done!\n");
+}
+
+// src/doctor.ts
+var import_corsen_context2 = require("@corsenai/corsen-context");
+function parseArgs2(args2) {
+  const result = {};
+  for (let i = 0; i < args2.length; i++) {
+    if ((args2[i] === "--url" || args2[i] === "-u") && args2[i + 1]) {
+      result.url = args2[++i];
+    }
+  }
+  return result;
+}
+async function doctor(args2) {
+  const { url } = parseArgs2(args2);
+  if (!url) {
+    console.error("  Error: --url is required");
+    console.error("  Usage: npx corsen-context doctor --url https://mysite.com");
+    process.exit(1);
+  }
+  console.log(`
+  Checking AI readiness for ${url}...
+`);
+  const results = [];
+  results.push({
+    name: "HTTPS",
+    status: url.startsWith("https://") ? "pass" : "fail",
+    message: url.startsWith("https://") ? "Site uses HTTPS" : "Site must use HTTPS"
+  });
+  const isPrivate = await (0, import_corsen_context2.isPrivateUrl)(url);
+  results.push({
+    name: "Public URL",
+    status: !isPrivate ? "pass" : "fail",
+    message: !isPrivate ? "URL is publicly accessible" : "URL points to private network"
+  });
+  const base = url.replace(/\/$/, "");
+  try {
+    const res = await fetch(`${base}/llms.txt`, {
+      signal: AbortSignal.timeout(1e4),
+      redirect: "follow"
+    });
+    results.push({
+      name: "llms.txt",
+      status: res.ok ? "pass" : "warn",
+      message: res.ok ? `Found /llms.txt (${res.status})` : `No /llms.txt found (${res.status})`
+    });
+  } catch {
+    results.push({
+      name: "llms.txt",
+      status: "warn",
+      message: "Could not check /llms.txt"
+    });
+  }
+  try {
+    const res = await fetch(`${base}/sitemap.xml`, {
+      signal: AbortSignal.timeout(1e4),
+      redirect: "follow"
+    });
+    results.push({
+      name: "Sitemap",
+      status: res.ok ? "pass" : "warn",
+      message: res.ok ? `Found /sitemap.xml (${res.status})` : `No /sitemap.xml found (${res.status})`
+    });
+  } catch {
+    results.push({
+      name: "Sitemap",
+      status: "warn",
+      message: "Could not check /sitemap.xml"
+    });
+  }
+  try {
+    const res = await fetch(`${base}/robots.txt`, {
+      signal: AbortSignal.timeout(1e4),
+      redirect: "follow"
+    });
+    if (res.ok) {
+      const text = await res.text();
+      const hasMcp = text.toLowerCase().includes("mcp:");
+      results.push({
+        name: "robots.txt MCP",
+        status: hasMcp ? "pass" : "warn",
+        message: hasMcp ? "robots.txt contains MCP endpoint reference" : "robots.txt exists but no MCP reference found"
+      });
+    } else {
+      results.push({
+        name: "robots.txt MCP",
+        status: "warn",
+        message: "No robots.txt found"
+      });
+    }
+  } catch {
+    results.push({
+      name: "robots.txt MCP",
+      status: "warn",
+      message: "Could not check robots.txt"
+    });
+  }
+  try {
+    const res = await fetch(`${base}/v1/mcp`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", method: "initialize", id: 1 }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const protocolVersion = data?.result?.protocolVersion;
+      results.push({
+        name: "MCP Endpoint",
+        status: protocolVersion ? "pass" : "warn",
+        message: protocolVersion ? `MCP endpoint active (protocol ${protocolVersion})` : "MCP endpoint responded but invalid protocol"
+      });
+    } else {
+      results.push({
+        name: "MCP Endpoint",
+        status: "warn",
+        message: `MCP endpoint at /v1/mcp returned ${res.status}`
+      });
+    }
+  } catch {
+    results.push({
+      name: "MCP Endpoint",
+      status: "warn",
+      message: "No MCP endpoint found at /v1/mcp"
+    });
+  }
+  const icons = { pass: "\u2705", fail: "\u274C", warn: "\u26A0\uFE0F" };
+  for (const r of results) {
+    console.log(`  ${icons[r.status]}  ${r.name}: ${r.message}`);
+  }
+  const passes = results.filter((r) => r.status === "pass").length;
+  const fails = results.filter((r) => r.status === "fail").length;
+  const warns = results.filter((r) => r.status === "warn").length;
+  console.log(`
+  Score: ${passes}/${results.length} checks passed`);
+  if (fails > 0) console.log(`  ${fails} critical issue(s) found`);
+  if (warns > 0) console.log(`  ${warns} warning(s)`);
+  if (passes === results.length) {
+    console.log("\n  Your site is AI-ready!\n");
+  } else {
+    console.log('\n  Run "npx corsen-context init" to set up missing components.\n');
+  }
+}
+
+// src/index.ts
+var import_corsen_context3 = require("@corsenai/corsen-context");
+var args = process.argv.slice(2);
+var command = args[0];
+var VERSION = import_corsen_context3.CORSEN_CONTEXT_VERSION;
+function printHelp() {
+  console.log(`
+  corsen-context v${VERSION}
+  ${import_corsen_context3.CREDIT_LINE}
+
+  Usage:
+    corsen-context <command> [options]
+
+  Commands:
+    init        Detect framework, create config & integration files
+    generate    Force regeneration of llms.txt and llms-full.txt
+    doctor      Check if your site is AI-ready (validate setup)
+
+  Options:
+    --help      Show this help message
+    --version   Show version number
+
+  Examples:
+    npx @corsenai/corsen-context-cli init
+    npx @corsenai/corsen-context-cli generate --url https://mysite.com
+    npx @corsenai/corsen-context-cli doctor --url https://mysite.com
+  `);
+}
+async function main() {
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command === "--version" || command === "-v") {
+    console.log(VERSION);
+    return;
+  }
+  switch (command) {
+    case "init":
+      await init();
+      break;
+    case "generate":
+      await generate(args.slice(1));
+      break;
+    case "doctor":
+      await doctor(args.slice(1));
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@corsenai/corsen-context-cli",
+  "version": "1.2.0",
+  "description": "CLI for Corsen Context — init, generate, and validate your AI context layer",
+  "author": "Corsen AI <contact@corsen.ai>",
+  "license": "MIT",
+  "homepage": "https://github.com/CorsenAI/corsen-context",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CorsenAI/corsen-context.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "mcp",
+    "llms-txt",
+    "ai",
+    "cli",
+    "corsen"
+  ],
+  "bin": {
+    "corsen-context": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@corsenai/corsen-context": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/CorsenAI/corsen-context/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}