@opencommerceprotocol/cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,3007 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_chalk12 = __toESM(require("chalk"));
+
+// src/commands/init.ts
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_spec = require("@opencommerceprotocol/spec");
+async function runInit(outputDir) {
+  const { default: inquirer } = await import("inquirer");
+  console.log(import_chalk.default.bold.cyan("\n\u{1F310} Open Commerce Protocol \u2014 Init Wizard\n"));
+  console.log("This wizard will generate your OCP manifest, protocol description, and a starter product feed.\n");
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Store name:",
+      validate: (v) => v.trim().length > 0 || "Store name is required"
+    },
+    {
+      type: "input",
+      name: "url",
+      message: "Store URL:",
+      default: "https://mystore.com",
+      validate: (v) => {
+        try {
+          new URL(v);
+          return true;
+        } catch {
+          return "Enter a valid URL (e.g. https://mystore.com)";
+        }
+      }
+    },
+    {
+      type: "list",
+      name: "platform",
+      message: "Platform:",
+      choices: [
+        { name: "WooCommerce (WordPress)", value: "woocommerce" },
+        { name: "Shopify", value: "shopify" },
+        { name: "Magento / Adobe Commerce", value: "magento" },
+        { name: "Custom / Other", value: "custom" }
+      ]
+    },
+    {
+      type: "input",
+      name: "currency",
+      message: "Primary currency (ISO 4217):",
+      default: "USD",
+      validate: (v) => /^[A-Z]{3}$/.test(v.trim()) || "Enter a 3-letter currency code (e.g. USD)",
+      filter: (v) => v.trim().toUpperCase()
+    },
+    {
+      type: "checkbox",
+      name: "capabilities",
+      message: "Capabilities (select all that apply):",
+      choices: [
+        { name: "Catalog \u2014 serve product listings", value: "catalog", checked: true },
+        { name: "Search \u2014 full-text search", value: "search", checked: true },
+        { name: "Cart \u2014 add/update cart items", value: "cart", checked: true },
+        { name: "Checkout \u2014 begin checkout flow", value: "checkout", checked: false },
+        { name: "Orders \u2014 track order status", value: "orders", checked: false }
+      ]
+    },
+    {
+      type: "confirm",
+      name: "includeRuntime",
+      message: "Include OCP runtime script in manifest?",
+      default: true
+    }
+  ]);
+  const storeUrl = answers.url.replace(/\/$/, "");
+  const feedUrl = `${storeUrl}/ocp/products.jsonl`;
+  const manifest = {
+    version: import_spec.OCP_VERSION,
+    merchant: {
+      name: answers.name,
+      url: storeUrl,
+      currency: answers.currency
+    },
+    capabilities: {
+      catalog: answers.capabilities.includes("catalog"),
+      search: answers.capabilities.includes("search"),
+      cart: answers.capabilities.includes("cart"),
+      checkout: answers.capabilities.includes("checkout") ? "redirect" : "none",
+      orders: answers.capabilities.includes("orders")
+    },
+    discovery: {
+      feed: feedUrl,
+      feed_format: "jsonl",
+      total_products: 0
+    },
+    permissions: {
+      requires_human_checkout: true
+    }
+  };
+  if (answers.includeRuntime) {
+    manifest.interact = {
+      runtime: "https://cdn.opencommerceprotocol.org/runtime/v1/ocp-runtime.min.js",
+      webmcp: true,
+      tools: [
+        ...answers.capabilities.includes("catalog") ? ["search_products", "get_product"] : [],
+        ...answers.capabilities.includes("cart") ? ["add_to_cart", "get_cart", "update_cart"] : [],
+        ...answers.capabilities.includes("checkout") ? ["begin_checkout"] : []
+      ]
+    };
+  }
+  const wellKnownDir = import_path.default.join(outputDir, ".well-known");
+  const ocpDir = import_path.default.join(outputDir, "ocp");
+  await import_fs.promises.mkdir(wellKnownDir, { recursive: true });
+  await import_fs.promises.mkdir(ocpDir, { recursive: true });
+  const manifestPath = import_path.default.join(wellKnownDir, "ocp.json");
+  await import_fs.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  const ocpMdContent = generateOcpMd(answers, storeUrl);
+  await import_fs.promises.writeFile(import_path.default.join(outputDir, "ocp.md"), ocpMdContent, "utf-8");
+  const starterFeed = generateStarterFeed(answers.name, storeUrl, answers.currency);
+  await import_fs.promises.writeFile(import_path.default.join(ocpDir, "products.jsonl"), starterFeed, "utf-8");
+  console.log("\n" + import_chalk.default.bold.green("\u2713 Generated:"));
+  console.log(import_chalk.default.green(`  .well-known/ocp.json`));
+  console.log(import_chalk.default.green(`  ocp.md`));
+  console.log(import_chalk.default.green(`  ocp/products.jsonl`) + import_chalk.default.dim("  (example template \u2014 replace with real products)"));
+  console.log("\n" + import_chalk.default.bold("Next steps:"));
+  console.log("  1. Edit " + import_chalk.default.cyan("ocp/products.jsonl") + " with your real product data");
+  console.log("  2. Serve " + import_chalk.default.cyan(".well-known/ocp.json") + " and " + import_chalk.default.cyan("ocp.md") + " from your web server");
+  console.log("  3. Run " + import_chalk.default.cyan("npx @opencommerceprotocol/cli validate " + storeUrl) + " to verify your implementation");
+  console.log("  4. (Optional) Add the OCP runtime script to your storefront pages\n");
+}
+function generateOcpMd(answers, storeUrl) {
+  return `# ${answers.name} \u2014 Open Commerce Protocol
+
+## About This Store
+
+${answers.name} is an online store located at ${storeUrl}.
+
+## What We Sell
+
+Describe your product catalog here. Include:
+- Main product categories
+- Price ranges
+- Target customers
+- Any specializations or unique offerings
+
+## How to Shop
+
+1. Use \`search_products\` to find products by keyword or category
+2. Use \`get_product\` to get detailed information on a specific item
+3. Use \`add_to_cart\` to add items to the cart
+4. Use \`begin_checkout\` to proceed to checkout (a human must complete payment)
+
+## Policies
+
+- **Returns**: Describe your return policy
+- **Shipping**: Describe shipping options and timelines
+- **Currency**: All prices in ${answers.currency}
+
+## Agent Notes
+
+- All purchases require human confirmation at checkout
+- Product availability is updated in real-time
+- Contact us for bulk orders or special requests
+
+*This document is optimized for AI agents. For the human-readable store, visit ${storeUrl}*
+`;
+}
+function generateStarterFeed(storeName, storeUrl, currency) {
+  const examples = [
+    {
+      id: "example-001",
+      name: "Example Product 1",
+      description: "Replace this with your real product description.",
+      price: 29.99,
+      currency,
+      url: `${storeUrl}/products/example-001`,
+      in_stock: true,
+      category: "Example Category",
+      agent_notes: "Replace with helpful notes for AI agents about this product.",
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      id: "example-002",
+      name: "Example Product 2",
+      description: `Another example product from ${storeName}.`,
+      price: 49.99,
+      currency,
+      url: `${storeUrl}/products/example-002`,
+      in_stock: true,
+      category: "Example Category",
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  ];
+  return examples.map((p) => JSON.stringify(p)).join("\n") + "\n";
+}
+
+// src/commands/validate.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_validator = require("@opencommerceprotocol/validator");
+function scoreColor(score) {
+  if (score >= 80) return import_chalk2.default.green(String(score));
+  if (score >= 50) return import_chalk2.default.yellow(String(score));
+  return import_chalk2.default.red(String(score));
+}
+function check(ok, msg) {
+  console.log((ok ? import_chalk2.default.green("  \u2713") : import_chalk2.default.red("  \u2717")) + " " + msg);
+}
+async function runValidate(target) {
+  const validator = new import_validator.OCPValidator();
+  if (target.startsWith("http://") || target.startsWith("https://")) {
+    await validateRemote(validator, target);
+  } else {
+    await validateLocal(validator, target);
+  }
+}
+async function validateRemote(validator, url) {
+  const { default: ora } = await import("ora");
+  const spinner = ora(`Validating ${import_chalk2.default.cyan(url)}`).start();
+  let result;
+  try {
+    result = await validator.validateRemote(url);
+    spinner.stop();
+  } catch (err) {
+    spinner.fail(`Failed to validate: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  console.log("\n" + import_chalk2.default.bold("OCP Validation Report"));
+  console.log(import_chalk2.default.dim("\u2501".repeat(50)));
+  console.log(import_chalk2.default.bold("URL:"), result.url);
+  console.log();
+  console.log(import_chalk2.default.bold("Manifest (/.well-known/ocp.json)"));
+  check(result.manifest.found, result.manifest.found ? "Found" : "Not found");
+  if (result.manifest.found) {
+    check(result.manifest.valid, result.manifest.valid ? "Valid" : "Invalid");
+    if (!result.manifest.valid) {
+      for (const err of result.manifest.errors.slice(0, 5)) {
+        console.log(import_chalk2.default.red(`     ${err.path}: ${err.message}`));
+      }
+    }
+  }
+  console.log();
+  console.log(import_chalk2.default.bold("Protocol Description (/ocp.md)"));
+  check(result.description.found, result.description.found ? "Found" : "Not found");
+  if (result.description.found) {
+    check(result.description.wellFormatted, result.description.wellFormatted ? "Well-formatted" : "Minimal content (expand for better agent understanding)");
+  }
+  console.log();
+  console.log(import_chalk2.default.bold("Product Feed"));
+  check(result.feed.found, result.feed.found ? "Found" : "Not found");
+  if (result.feed.found && result.feed.result) {
+    const { totalProducts, validProducts, invalidProducts } = result.feed.result;
+    console.log(`  ${import_chalk2.default.dim("\u2500")} ${totalProducts} products: ${import_chalk2.default.green(String(validProducts))} valid, ${invalidProducts > 0 ? import_chalk2.default.red(String(invalidProducts)) : "0"} invalid`);
+    if (result.feed.result.agentNotesQuality) {
+      const q = result.feed.result.agentNotesQuality;
+      const pct = totalProducts > 0 ? Math.round(q.withNotes / totalProducts * 100) : 0;
+      const color = pct >= 80 ? import_chalk2.default.green : pct >= 50 ? import_chalk2.default.yellow : import_chalk2.default.red;
+      console.log(`  ${import_chalk2.default.dim("\u2500")} agent_notes: ${color(`${pct}%`)} coverage, avg score ${q.avgScore}/100`);
+      if (q.missing > 0) {
+        console.log(`    ${import_chalk2.default.yellow(`${q.missing} products missing agent_notes`)}`);
+      }
+      if (q.poor > 0) {
+        console.log(`    ${import_chalk2.default.yellow(`${q.poor} products have poor quality notes (score < 50)`)}`);
+      }
+    }
+  }
+  console.log();
+  console.log(import_chalk2.default.bold("Bridges"));
+  check(result.bridges.mcp, result.bridges.mcp ? "MCP bridge" : "MCP bridge (not configured)");
+  check(result.bridges.ucp, result.bridges.ucp ? "UCP bridge" : "UCP bridge (not configured)");
+  check(result.bridges.acp, result.bridges.acp ? "ACP bridge" : "ACP bridge (not configured)");
+  check(result.bridges.a2a, result.bridges.a2a ? "A2A bridge" : "A2A bridge (not configured)");
+  console.log();
+  console.log(import_chalk2.default.bold("Discovery"));
+  try {
+    const robotsResult = await (0, import_validator.validateRobotsTxt)(result.url);
+    check(robotsResult.hasOcpDirective, robotsResult.hasOcpDirective ? "robots.txt OCP-Manifest directive" : "robots.txt OCP-Manifest directive (not found)");
+  } catch {
+    check(false, "robots.txt (could not check)");
+  }
+  try {
+    const llmsResult = await (0, import_validator.validateLlmsTxt)(result.url);
+    check(llmsResult.hasLlmsTxt, llmsResult.hasLlmsTxt ? "llms.txt found" : "llms.txt (not found)");
+    if (llmsResult.hasLlmsTxt) {
+      check(llmsResult.hasCommerceSection, llmsResult.hasCommerceSection ? "llms.txt ## Commerce section" : "llms.txt ## Commerce section (not found)");
+    }
+  } catch {
+    check(false, "llms.txt (could not check)");
+  }
+  if (result.recommendations.length > 0) {
+    console.log();
+    console.log(import_chalk2.default.bold("Recommendations"));
+    for (const rec of result.recommendations) {
+      console.log(import_chalk2.default.yellow("  \u2192 ") + rec);
+    }
+  }
+  console.log();
+  console.log(import_chalk2.default.dim("\u2501".repeat(50)));
+  console.log(import_chalk2.default.bold("Score: ") + scoreColor(result.score) + import_chalk2.default.dim("/100"));
+  if (result.score === 100) {
+    console.log(import_chalk2.default.green.bold("\n\u{1F389} Perfect score! Your store is fully OCP-compliant.\n"));
+  } else if (result.score >= 80) {
+    console.log(import_chalk2.default.green("\n\u2713 Good implementation. Follow the recommendations to improve.\n"));
+  } else if (result.score >= 50) {
+    console.log(import_chalk2.default.yellow("\n\u26A0 Partial implementation. Follow the recommendations to complete setup.\n"));
+  } else {
+    console.log(import_chalk2.default.red("\n\u2717 Incomplete implementation. See recommendations above.\n"));
+  }
+}
+async function validateLocal(validator, dirPath) {
+  const { promises: fs8 } = await import("fs");
+  const path7 = await import("path");
+  console.log("\n" + import_chalk2.default.bold("OCP Local Validation"));
+  console.log(import_chalk2.default.dim("\u2501".repeat(50)));
+  console.log(import_chalk2.default.bold("Directory:"), dirPath);
+  console.log();
+  const manifestPath = path7.join(dirPath, ".well-known", "ocp.json");
+  try {
+    const raw = await fs8.readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    const result = validator.validateManifest(manifest);
+    check(true, ".well-known/ocp.json \u2014 found");
+    check(result.valid, result.valid ? "Valid manifest" : "Invalid manifest");
+    if (!result.valid) {
+      for (const err of result.errors.slice(0, 10)) {
+        console.log(import_chalk2.default.red(`   ${err.path}: ${err.message}`));
+      }
+    }
+  } catch {
+    check(false, ".well-known/ocp.json \u2014 not found");
+  }
+  try {
+    const md = await fs8.readFile(path7.join(dirPath, "ocp.md"), "utf-8");
+    check(true, `ocp.md \u2014 found (${md.length} bytes)`);
+  } catch {
+    check(false, "ocp.md \u2014 not found");
+  }
+  const feedPath = path7.join(dirPath, "ocp", "products.jsonl");
+  try {
+    const raw = await fs8.readFile(feedPath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    let valid = 0;
+    let invalid = 0;
+    for (const line of lines) {
+      try {
+        const product = JSON.parse(line);
+        const result = validator.validateProduct(product);
+        if (result.valid) valid++;
+        else invalid++;
+      } catch {
+        invalid++;
+      }
+    }
+    check(true, `ocp/products.jsonl \u2014 ${lines.length} products (${valid} valid, ${invalid} invalid)`);
+  } catch {
+    check(false, "ocp/products.jsonl \u2014 not found");
+  }
+  try {
+    const robotsContent = await fs8.readFile(path7.join(dirPath, "robots.txt"), "utf-8");
+    const hasOcp = robotsContent.toLowerCase().includes("ocp-manifest:");
+    check(hasOcp, hasOcp ? "robots.txt \u2014 OCP-Manifest directive present" : "robots.txt \u2014 found but no OCP-Manifest directive");
+  } catch {
+    check(false, "robots.txt \u2014 not found");
+  }
+  try {
+    const llmsContent = await fs8.readFile(path7.join(dirPath, "llms.txt"), "utf-8");
+    const hasCommerce = llmsContent.includes("## Commerce");
+    check(hasCommerce, hasCommerce ? "llms.txt \u2014 ## Commerce section present" : "llms.txt \u2014 found but no ## Commerce section");
+  } catch {
+    check(false, "llms.txt \u2014 not found");
+  }
+  console.log();
+}
+
+// src/commands/generate.ts
+var import_fs2 = require("fs");
+var import_path2 = __toESM(require("path"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_spec2 = require("@opencommerceprotocol/spec");
+function mapRow(row, currency) {
+  const id = row["id"] || row["sku"] || row["product_id"];
+  const name = row["name"] || row["title"] || row["product_name"];
+  const priceRaw = row["price"] || row["sale_price"] || row["regular_price"];
+  if (!id || !name || !priceRaw) return null;
+  const price = parseFloat(String(priceRaw).replace(/[^0-9.]/g, ""));
+  if (isNaN(price)) return null;
+  return {
+    id: String(id),
+    name: String(name),
+    description: row["description"] || row["desc"] || row["body_html"],
+    price,
+    currency: row["currency"] || currency,
+    url: row["url"] || row["link"] || row["permalink"] || "",
+    image: row["image"] || row["img"] || row["image_src"] || row["featured_image"],
+    in_stock: row["in_stock"] !== void 0 ? Boolean(row["in_stock"]) : row["stock_status"] === "instock" || row["available"] === "true",
+    category: row["category"] || row["product_type"] || row["type"],
+    sku: row["sku"] || void 0,
+    brand: row["brand"] || row["vendor"] || void 0,
+    agent_notes: row["agent_notes"] || void 0,
+    updated_at: row["updated_at"] || row["date_modified"] || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function runGenerate(options) {
+  const outputDir = options.output || ".";
+  const currency = "USD";
+  if (!options.products) {
+    console.error(import_chalk3.default.red("Error: --products file is required"));
+    process.exit(1);
+  }
+  const inputPath = import_path2.default.resolve(options.products);
+  const ext = import_path2.default.extname(inputPath).toLowerCase();
+  const raw = await import_fs2.promises.readFile(inputPath, "utf-8");
+  let products = [];
+  const errors = [];
+  if (ext === ".csv") {
+    const Papa = require("papaparse");
+    const { data } = Papa.parse(raw, { header: true, skipEmptyLines: true });
+    for (let i = 0; i < data.length; i++) {
+      const mapped = mapRow(data[i], currency);
+      if (mapped) {
+        products.push(mapped);
+      } else {
+        errors.push(`Row ${i + 2}: could not map required fields (id, name, price)`);
+      }
+    }
+  } else if (ext === ".json") {
+    const data = JSON.parse(raw);
+    for (let i = 0; i < data.length; i++) {
+      const mapped = mapRow(data[i], currency);
+      if (mapped) products.push(mapped);
+      else errors.push(`Item ${i}: could not map required fields`);
+    }
+  } else if (ext === ".jsonl") {
+    const lines = raw.split("\n").filter((l) => l.trim());
+    for (let i = 0; i < lines.length; i++) {
+      try {
+        const row = JSON.parse(lines[i]);
+        const mapped = mapRow(row, currency);
+        if (mapped) products.push(mapped);
+        else errors.push(`Line ${i + 1}: could not map required fields`);
+      } catch {
+        errors.push(`Line ${i + 1}: invalid JSON`);
+      }
+    }
+  } else {
+    console.error(import_chalk3.default.red(`Unsupported format: ${ext}. Use .csv, .json, or .jsonl`));
+    process.exit(1);
+  }
+  const ocpDir = import_path2.default.join(outputDir, "ocp");
+  await import_fs2.promises.mkdir(ocpDir, { recursive: true });
+  await import_fs2.promises.mkdir(import_path2.default.join(outputDir, ".well-known"), { recursive: true });
+  const feedPath = import_path2.default.join(ocpDir, "products.jsonl");
+  await import_fs2.promises.writeFile(feedPath, products.map((p) => JSON.stringify(p)).join("\n") + "\n", "utf-8");
+  const manifestPath = import_path2.default.join(outputDir, ".well-known", "ocp.json");
+  let manifest;
+  try {
+    manifest = JSON.parse(await import_fs2.promises.readFile(manifestPath, "utf-8"));
+  } catch {
+    manifest = {
+      version: import_spec2.OCP_VERSION,
+      merchant: { name: "My Store", url: "https://mystore.com" },
+      capabilities: { catalog: true }
+    };
+  }
+  const discovery = manifest["discovery"] || {};
+  discovery["total_products"] = products.length;
+  discovery["feed_updated"] = (/* @__PURE__ */ new Date()).toISOString();
+  manifest["discovery"] = discovery;
+  await import_fs2.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  const emap = {};
+  void emap;
+  console.log(import_chalk3.default.bold.green("\n\u2713 OCP files generated:"));
+  console.log(import_chalk3.default.green(`  ocp/products.jsonl`), import_chalk3.default.dim(`\u2014 ${products.length} products`));
+  console.log(import_chalk3.default.green(`  .well-known/ocp.json`), import_chalk3.default.dim("\u2014 updated total_products"));
+  if (errors.length > 0) {
+    console.log(import_chalk3.default.yellow(`
+\u26A0 ${errors.length} rows skipped:`));
+    for (const e of errors.slice(0, 5)) {
+      console.log(import_chalk3.default.yellow(`  ${e}`));
+    }
+    if (errors.length > 5) {
+      console.log(import_chalk3.default.yellow(`  ...and ${errors.length - 5} more`));
+    }
+  }
+  console.log();
+}
+
+// src/commands/bridge.ts
+var import_fs3 = require("fs");
+var import_path3 = __toESM(require("path"));
+var import_chalk4 = __toESM(require("chalk"));
+async function runBridge(options) {
+  const outputDir = options.output || ".";
+  const manifestPath = options.manifest || ".well-known/ocp.json";
+  let manifest;
+  try {
+    manifest = JSON.parse(await import_fs3.promises.readFile(manifestPath, "utf-8"));
+  } catch {
+    console.error(import_chalk4.default.red(`Could not read manifest at ${manifestPath}`));
+    console.error(import_chalk4.default.dim("Run `ocp init` first to generate your manifest."));
+    process.exit(1);
+  }
+  switch (options.protocol.toLowerCase()) {
+    case "mcp":
+      await generateMCPBridge(manifest, outputDir);
+      break;
+    case "ucp":
+      await generateUCPBridge(manifest, outputDir);
+      break;
+    case "a2a":
+      await generateA2ABridge(manifest, outputDir);
+      break;
+    default:
+      console.error(import_chalk4.default.red(`Unknown protocol: ${options.protocol}`));
+      console.error("Supported protocols: mcp, ucp, a2a");
+      process.exit(1);
+  }
+}
+async function generateMCPBridge(manifest, outputDir) {
+  const merchant = manifest["merchant"];
+  const mcpConfig = {
+    name: `${merchant.name} MCP Server`,
+    version: "1.0.0",
+    ocp_manifest: `${merchant.url}/.well-known/ocp.json`,
+    transport: "stdio",
+    description: `MCP server bridging ${merchant.name} OCP tools`
+  };
+  const serverCode = `#!/usr/bin/env node
+/**
+ * MCP Server Bridge for ${merchant.name}
+ * Generated by @opencommerceprotocol/cli
+ */
+import { createMCPServer } from '@opencommerceprotocol/bridge-mcp';
+import manifest from './ocp-manifest.json' assert { type: 'json' };
+
+const server = createMCPServer(manifest);
+server.start();
+`;
+  await import_fs3.promises.mkdir(outputDir, { recursive: true });
+  await import_fs3.promises.writeFile(import_path3.default.join(outputDir, "mcp-server.js"), serverCode, "utf-8");
+  await import_fs3.promises.writeFile(
+    import_path3.default.join(outputDir, "ocp-manifest.json"),
+    JSON.stringify(manifest, null, 2),
+    "utf-8"
+  );
+  await import_fs3.promises.writeFile(
+    import_path3.default.join(outputDir, "mcp-config.json"),
+    JSON.stringify(mcpConfig, null, 2),
+    "utf-8"
+  );
+  console.log(import_chalk4.default.bold.green("\n\u2713 MCP bridge generated:"));
+  console.log(import_chalk4.default.green(`  ${outputDir}/mcp-server.js`));
+  console.log(import_chalk4.default.green(`  ${outputDir}/mcp-config.json`));
+  console.log("\n" + import_chalk4.default.bold("Next steps:"));
+  console.log(`  1. cd ${outputDir}`);
+  console.log("  2. npm install @opencommerceprotocol/bridge-mcp");
+  console.log("  3. node mcp-server.js\n");
+}
+async function generateUCPBridge(manifest, outputDir) {
+  const merchant = manifest["merchant"];
+  const caps = manifest["capabilities"] || {};
+  const ucpManifest = {
+    "@context": "https://schema.googleapis.com/ucp/v1",
+    type: "UniversalCheckoutProvider",
+    name: merchant.name,
+    url: merchant.url,
+    capabilities: {
+      checkout: caps["checkout"] !== "none",
+      catalog: caps["catalog"] === true,
+      search: caps["search"] === true
+    },
+    currency: merchant.currency || "USD",
+    ocp_source: `${merchant.url}/.well-known/ocp.json`
+  };
+  await import_fs3.promises.mkdir(outputDir, { recursive: true });
+  await import_fs3.promises.writeFile(
+    import_path3.default.join(outputDir, "ucp-manifest.json"),
+    JSON.stringify(ucpManifest, null, 2),
+    "utf-8"
+  );
+  console.log(import_chalk4.default.bold.green("\n\u2713 UCP bridge manifest generated:"));
+  console.log(import_chalk4.default.green(`  ${outputDir}/ucp-manifest.json`));
+  console.log("\n" + import_chalk4.default.bold("Next steps:"));
+  console.log("  Serve this file at /.well-known/ucp on your domain\n");
+}
+async function generateA2ABridge(manifest, outputDir) {
+  const merchant = manifest["merchant"];
+  const interact = manifest["interact"];
+  const a2aCard = {
+    "@context": "https://schema.googleapis.com/a2a/v1",
+    type: "AgentCard",
+    name: `${merchant.name} Shopping Agent`,
+    description: merchant.description || `AI shopping agent for ${merchant.name}`,
+    url: merchant.url,
+    skills: (interact?.tools || ["search_products", "get_product"]).map((tool) => ({
+      id: tool,
+      name: tool.replace(/_/g, " "),
+      description: `OCP tool: ${tool}`
+    })),
+    ocp_source: `${merchant.url}/.well-known/ocp.json`
+  };
+  await import_fs3.promises.mkdir(outputDir, { recursive: true });
+  await import_fs3.promises.writeFile(
+    import_path3.default.join(outputDir, "a2a-agent-card.json"),
+    JSON.stringify(a2aCard, null, 2),
+    "utf-8"
+  );
+  console.log(import_chalk4.default.bold.green("\n\u2713 A2A agent card generated:"));
+  console.log(import_chalk4.default.green(`  ${outputDir}/a2a-agent-card.json`));
+  console.log("\n" + import_chalk4.default.bold("Next steps:"));
+  console.log("  Serve this file at /.well-known/agent.json on your domain\n");
+}
+
+// src/commands/crawl.ts
+var import_fs4 = require("fs");
+var import_path4 = __toESM(require("path"));
+var import_chalk5 = __toESM(require("chalk"));
+var import_spec3 = require("@opencommerceprotocol/spec");
+
+// src/utils/http.ts
+var DEFAULT_USER_AGENT = "OCPBot/1.0 (+https://opencommerceprotocol.org/bot)";
+var HttpClient = class {
+  userAgent;
+  minDelay;
+  retries;
+  timeout;
+  lastRequestTime = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    this.minDelay = options.minDelay ?? 200;
+    this.retries = options.retries ?? 2;
+    this.timeout = options.timeout ?? 3e4;
+  }
+  /**
+   * Set the minimum delay between requests (e.g. from Crawl-delay).
+   * @param ms - Delay in milliseconds
+   */
+  setMinDelay(ms) {
+    this.minDelay = Math.max(100, ms);
+  }
+  /**
+   * Fetch a URL with rate limiting and retries.
+   * @param url - The URL to fetch
+   * @returns The HTTP response
+   */
+  async get(url) {
+    const host = new URL(url).host;
+    const lastTime = this.lastRequestTime.get(host) ?? 0;
+    const elapsed = Date.now() - lastTime;
+    if (elapsed < this.minDelay) {
+      await sleep(this.minDelay - elapsed);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        this.lastRequestTime.set(host, Date.now());
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, {
+          headers: {
+            "User-Agent": this.userAgent,
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+          },
+          signal: controller.signal,
+          redirect: "follow"
+        });
+        clearTimeout(timer);
+        const text = await response.text();
+        const headers = {};
+        response.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        return {
+          status: response.status,
+          text,
+          headers,
+          url: response.url,
+          ok: response.ok
+        };
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < this.retries) {
+          await sleep(1e3 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError ?? new Error(`Failed to fetch ${url}`);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/robots.ts
+function parseRobotsTxt(content) {
+  const lines = content.split("\n");
+  const groups = [];
+  const sitemaps = [];
+  let ocpManifest;
+  let currentGroup = null;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const directive = line.substring(0, colonIdx).trim().toLowerCase();
+    const value = line.substring(colonIdx + 1).trim();
+    switch (directive) {
+      case "user-agent":
+        if (!currentGroup || currentGroup.rules.length > 0) {
+          currentGroup = { userAgents: [], rules: [] };
+          groups.push(currentGroup);
+        }
+        currentGroup.userAgents.push(value);
+        break;
+      case "allow":
+        if (currentGroup) {
+          currentGroup.rules.push({ type: "allow", path: value });
+        }
+        break;
+      case "disallow":
+        if (currentGroup) {
+          currentGroup.rules.push({ type: "disallow", path: value });
+        }
+        break;
+      case "crawl-delay":
+        if (currentGroup) {
+          const delay = parseFloat(value);
+          if (!isNaN(delay)) {
+            currentGroup.crawlDelay = delay;
+          }
+        }
+        break;
+      case "sitemap":
+        sitemaps.push(value);
+        break;
+      case "ocp-manifest":
+        ocpManifest = value;
+        break;
+    }
+  }
+  return { groups, sitemaps, ocpManifest, raw: content };
+}
+function isPathAllowed(robots, urlPath, userAgent = "*") {
+  const matchedGroup = findMatchingGroup(robots, userAgent);
+  if (!matchedGroup) return true;
+  let bestMatch;
+  let bestLength = -1;
+  for (const rule of matchedGroup.rules) {
+    if (urlPath.startsWith(rule.path) && rule.path.length > bestLength) {
+      bestMatch = rule;
+      bestLength = rule.path.length;
+    }
+  }
+  if (!bestMatch) return true;
+  return bestMatch.type === "allow";
+}
+function getCrawlDelay(robots, userAgent = "*") {
+  const matchedGroup = findMatchingGroup(robots, userAgent);
+  return matchedGroup?.crawlDelay;
+}
+function findMatchingGroup(robots, userAgent) {
+  const ua = userAgent.toLowerCase();
+  let wildcardGroup;
+  for (const group of robots.groups) {
+    for (const agent of group.userAgents) {
+      if (agent === "*") {
+        if (!wildcardGroup) wildcardGroup = group;
+      } else if (ua.includes(agent.toLowerCase())) {
+        return group;
+      }
+    }
+  }
+  return wildcardGroup;
+}
+function patchRobotsTxt(content, manifestUrl) {
+  const parsed = parseRobotsTxt(content);
+  if (parsed.ocpManifest) {
+    return content;
+  }
+  const directive = `OCP-Manifest: ${manifestUrl}`;
+  const lines = content.split("\n");
+  let lastSitemapIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().toLowerCase().startsWith("sitemap:")) {
+      lastSitemapIdx = i;
+    }
+  }
+  if (lastSitemapIdx >= 0) {
+    lines.splice(lastSitemapIdx + 1, 0, directive);
+  } else {
+    const trimmed = content.trimEnd();
+    if (trimmed.length > 0) {
+      return trimmed + "\n" + directive + "\n";
+    }
+    return directive + "\n";
+  }
+  return lines.join("\n");
+}
+
+// src/utils/sitemap.ts
+var DEFAULT_PRODUCT_PATTERNS = [
+  /\/products?\//i,
+  /\/shop\//i,
+  /\/item\//i,
+  /\/p\//i,
+  /\/catalog\//i,
+  /\/goods?\//i
+];
+function parseSitemapXml(xml) {
+  const urls = [];
+  const childSitemaps = [];
+  const isIndex = /<sitemapindex[\s>]/i.test(xml);
+  if (isIndex) {
+    const sitemapRegex = /<sitemap[^>]*>([\s\S]*?)<\/sitemap>/gi;
+    let match;
+    while ((match = sitemapRegex.exec(xml)) !== null) {
+      const loc = extractTag(match[1], "loc");
+      if (loc) childSitemaps.push(loc);
+    }
+  } else {
+    const urlRegex = /<url[^>]*>([\s\S]*?)<\/url>/gi;
+    let match;
+    while ((match = urlRegex.exec(xml)) !== null) {
+      const loc = extractTag(match[1], "loc");
+      if (!loc) continue;
+      const entry = { loc };
+      const lastmod = extractTag(match[1], "lastmod");
+      if (lastmod) entry.lastmod = lastmod;
+      const changefreq = extractTag(match[1], "changefreq");
+      if (changefreq) entry.changefreq = changefreq;
+      const priority = extractTag(match[1], "priority");
+      if (priority) {
+        const p = parseFloat(priority);
+        if (!isNaN(p)) entry.priority = p;
+      }
+      urls.push(entry);
+    }
+  }
+  return { urls, isIndex, childSitemaps };
+}
+function extractTag(xml, tag) {
+  const regex = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i");
+  const match = regex.exec(xml);
+  return match?.[1]?.trim();
+}
+function filterProductUrls(urls, customPattern) {
+  const patterns = customPattern ? [customPattern] : DEFAULT_PRODUCT_PATTERNS;
+  return urls.filter((u) => {
+    try {
+      const path7 = new URL(u.loc).pathname;
+      return patterns.some((p) => p.test(path7));
+    } catch {
+      return false;
+    }
+  });
+}
+async function fetchSitemap(url, client, maxDepth = 3) {
+  if (maxDepth <= 0) return [];
+  const response = await client.get(url);
+  if (!response.ok) return [];
+  const result = parseSitemapXml(response.text);
+  if (result.isIndex) {
+    const allUrls = [];
+    for (const childUrl of result.childSitemaps) {
+      const childUrls = await fetchSitemap(childUrl, client, maxDepth - 1);
+      allUrls.push(...childUrls);
+    }
+    return allUrls;
+  }
+  return result.urls;
+}
+
+// src/utils/jsonld-extractor.ts
+function extractJsonLdBlocks(html) {
+  const blocks = [];
+  const regex = /<script[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1]);
+      blocks.push(parsed);
+    } catch {
+    }
+  }
+  return blocks;
+}
+function findProductObjects(blocks) {
+  const products = [];
+  for (const block of blocks) {
+    if (!block || typeof block !== "object") continue;
+    const obj = block;
+    if (Array.isArray(obj["@graph"])) {
+      for (const item of obj["@graph"]) {
+        if (isProductType(item)) {
+          products.push(item);
+        }
+      }
+      continue;
+    }
+    if (Array.isArray(block)) {
+      for (const item of block) {
+        if (isProductType(item)) {
+          products.push(item);
+        }
+      }
+      continue;
+    }
+    if (isProductType(obj)) {
+      products.push(obj);
+    }
+  }
+  return products;
+}
+function isProductType(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const typed = obj;
+  const type = typed["@type"];
+  if (typeof type === "string") {
+    return type === "Product" || type === "https://schema.org/Product" || type === "schema:Product";
+  }
+  if (Array.isArray(type)) {
+    return type.some(
+      (t) => t === "Product" || t === "https://schema.org/Product" || t === "schema:Product"
+    );
+  }
+  return false;
+}
+function extractProductsFromHtml(html, sourceUrl) {
+  const blocks = extractJsonLdBlocks(html);
+  const productObjects = findProductObjects(blocks);
+  return productObjects.map((raw) => ({
+    raw,
+    sourceUrl
+  }));
+}
+function extractPageMetadata(html) {
+  const titleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+  const descMatch = /<meta[^>]*name\s*=\s*["']description["'][^>]*content\s*=\s*["']([\s\S]*?)["'][^>]*>/i.exec(html) || /<meta[^>]*content\s*=\s*["']([\s\S]*?)["'][^>]*name\s*=\s*["']description["'][^>]*>/i.exec(html);
+  return {
+    title: titleMatch?.[1]?.trim(),
+    description: descMatch?.[1]?.trim()
+  };
+}
+
+// src/utils/schema-mapper.ts
+var AVAILABILITY_MAP = {
+  "https://schema.org/InStock": true,
+  "http://schema.org/InStock": true,
+  "InStock": true,
+  "https://schema.org/LimitedAvailability": true,
+  "http://schema.org/LimitedAvailability": true,
+  "LimitedAvailability": true,
+  "https://schema.org/PreOrder": true,
+  "http://schema.org/PreOrder": true,
+  "PreOrder": true,
+  "https://schema.org/OnlineOnly": true,
+  "http://schema.org/OnlineOnly": true,
+  "OnlineOnly": true,
+  "https://schema.org/OutOfStock": false,
+  "http://schema.org/OutOfStock": false,
+  "OutOfStock": false,
+  "https://schema.org/Discontinued": false,
+  "http://schema.org/Discontinued": false,
+  "Discontinued": false,
+  "https://schema.org/SoldOut": false,
+  "http://schema.org/SoldOut": false,
+  "SoldOut": false
+};
+function mapSchemaOrgToOCP(product) {
+  const raw = product.raw;
+  const sourceUrl = product.sourceUrl;
+  const name = getString(raw, "name");
+  if (!name) return null;
+  const id = getString(raw, "sku") || generateIdFromUrl(sourceUrl);
+  const offers = getOffers(raw);
+  const primaryOffer = offers[0];
+  const price = primaryOffer ? parsePrice(primaryOffer["price"]) : void 0;
+  const currency = primaryOffer ? getString(primaryOffer, "priceCurrency") : void 0;
+  if (price === void 0 || !currency) return null;
+  const result = {
+    id,
+    name,
+    price,
+    currency,
+    url: getString(raw, "url") || (primaryOffer ? getString(primaryOffer, "url") : void 0) || sourceUrl
+  };
+  const description = getString(raw, "description");
+  if (description) result.description = description;
+  const image = resolveImage(raw["image"], sourceUrl);
+  if (image) result.image = image;
+  const images = resolveImages(raw["image"], sourceUrl);
+  if (images && images.length > 1) result.images = images;
+  if (primaryOffer?.["availability"]) {
+    const avail = String(primaryOffer["availability"]);
+    if (avail in AVAILABILITY_MAP) {
+      result.in_stock = AVAILABILITY_MAP[avail];
+    }
+  }
+  const category = getString(raw, "category");
+  if (category) result.category = category;
+  const brand = extractBrandName(raw);
+  if (brand) result.brand = brand;
+  const sku = getString(raw, "sku");
+  if (sku) result.sku = sku;
+  const attributes = {};
+  const gtin = getString(raw, "gtin") || getString(raw, "gtin13") || getString(raw, "gtin8") || getString(raw, "gtin12") || getString(raw, "gtin14");
+  if (gtin) attributes["gtin"] = gtin;
+  const aggregateRating = raw["aggregateRating"];
+  if (aggregateRating && typeof aggregateRating === "object") {
+    const ratingValue = parseFloat(String(aggregateRating["ratingValue"] ?? ""));
+    if (!isNaN(ratingValue)) attributes["rating"] = ratingValue;
+    const reviewCount = parseInt(String(aggregateRating["reviewCount"] ?? aggregateRating["ratingCount"] ?? ""), 10);
+    if (!isNaN(reviewCount)) attributes["review_count"] = reviewCount;
+  }
+  const color = getString(raw, "color");
+  if (color) attributes["color"] = color;
+  const material = getString(raw, "material");
+  if (material) attributes["material"] = material;
+  const weight = raw["weight"];
+  if (weight && typeof weight === "object") {
+    const w = weight;
+    const value = parseFloat(String(w["value"] ?? ""));
+    const unit = getString(w, "unitText") || getString(w, "unitCode") || "g";
+    if (!isNaN(value)) {
+      attributes["weight"] = `${value} ${unit}`;
+      result.weight = convertToGrams(value, unit);
+    }
+  }
+  if (Object.keys(attributes).length > 0) {
+    result.attributes = attributes;
+  }
+  const variants = extractVariants(raw, sourceUrl);
+  if (variants.length > 0) result.variants = variants;
+  const specs = extractSpecs(raw);
+  if (specs.length > 0) result.specs = specs;
+  if (primaryOffer) {
+    const promotions = extractPromotions(primaryOffer);
+    if (promotions.length > 0) result.promotions = promotions;
+    const pricePerUnit = extractPricePerUnit(primaryOffer);
+    if (pricePerUnit) result.price_per_unit = pricePerUnit;
+  }
+  result.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  return result;
+}
+function getString(obj, key) {
+  const val = obj[key];
+  if (typeof val === "string") return val.trim() || void 0;
+  if (typeof val === "number") return String(val);
+  return void 0;
+}
+function getOffers(raw) {
+  const offers = raw["offers"];
+  if (!offers) return [];
+  if (Array.isArray(offers)) {
+    return offers.filter((o) => typeof o === "object" && o !== null);
+  }
+  if (typeof offers === "object") {
+    const o = offers;
+    if (o["@type"] === "AggregateOffer") {
+      const nestedOffers = o["offers"];
+      if (Array.isArray(nestedOffers)) {
+        return nestedOffers.filter((x) => typeof x === "object" && x !== null);
+      }
+      if (o["lowPrice"]) {
+        return [{ ...o, price: o["lowPrice"] }];
+      }
+    }
+    return [o];
+  }
+  return [];
+}
+function parsePrice(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const cleaned = value.replace(/[^0-9.,]/g, "").replace(/,(\d{3})/g, "$1").replace(/,/g, ".");
+    const parsed = parseFloat(cleaned);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  return void 0;
+}
+function resolveImage(image, baseUrl) {
+  if (typeof image === "string") return resolveUrl(image, baseUrl);
+  if (Array.isArray(image)) {
+    const first = image[0];
+    if (typeof first === "string") return resolveUrl(first, baseUrl);
+    if (typeof first === "object" && first !== null) {
+      const url = first["url"] || first["contentUrl"];
+      if (typeof url === "string") return resolveUrl(url, baseUrl);
+    }
+  }
+  if (typeof image === "object" && image !== null) {
+    const obj = image;
+    const url = obj["url"] || obj["contentUrl"];
+    if (typeof url === "string") return resolveUrl(url, baseUrl);
+  }
+  return void 0;
+}
+function resolveImages(image, baseUrl) {
+  if (typeof image === "string") return [resolveUrl(image, baseUrl)];
+  if (Array.isArray(image)) {
+    const urls = [];
+    for (const item of image) {
+      if (typeof item === "string") {
+        urls.push(resolveUrl(item, baseUrl));
+      } else if (typeof item === "object" && item !== null) {
+        const url = item["url"] || item["contentUrl"];
+        if (typeof url === "string") urls.push(resolveUrl(url, baseUrl));
+      }
+    }
+    return urls.length > 0 ? urls : void 0;
+  }
+  return void 0;
+}
+function resolveUrl(url, baseUrl) {
+  try {
+    return new URL(url, baseUrl).href;
+  } catch {
+    return url;
+  }
+}
+function extractBrandName(raw) {
+  const brand = raw["brand"];
+  if (typeof brand === "string") return brand;
+  if (typeof brand === "object" && brand !== null) {
+    const b = brand;
+    return getString(b, "name");
+  }
+  return void 0;
+}
+function generateIdFromUrl(url) {
+  try {
+    const pathname = new URL(url).pathname;
+    const slug = pathname.split("/").filter(Boolean).pop();
+    return slug || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function convertToGrams(value, unit) {
+  const u = unit.toLowerCase();
+  if (u === "kg" || u === "kgm") return value * 1e3;
+  if (u === "lb" || u === "lbs" || u === "lbm") return value * 453.592;
+  if (u === "oz" || u === "onz") return value * 28.3495;
+  return value;
+}
+function extractSpecs(raw) {
+  const specs = [];
+  const additionalProperty = raw["additionalProperty"];
+  if (!Array.isArray(additionalProperty)) return specs;
+  for (const prop of additionalProperty) {
+    if (typeof prop !== "object" || prop === null) continue;
+    const p = prop;
+    const name = getString(p, "name");
+    if (!name) continue;
+    let value;
+    const rawValue = p["value"];
+    if (typeof rawValue === "string") value = rawValue;
+    else if (typeof rawValue === "number") value = rawValue;
+    else if (typeof rawValue === "boolean") value = rawValue;
+    else continue;
+    const spec = { name, value };
+    const unitText = getString(p, "unitText") || getString(p, "unitCode");
+    if (unitText) spec.unit = unitText;
+    const propertyID = getString(p, "propertyID");
+    if (propertyID) spec.group = propertyID;
+    specs.push(spec);
+  }
+  return specs;
+}
+function extractPromotions(offer) {
+  const promotions = [];
+  const priceSpec = offer["priceSpecification"];
+  if (Array.isArray(priceSpec)) {
+    for (const spec of priceSpec) {
+      if (typeof spec !== "object" || spec === null) continue;
+      const s = spec;
+      const type = getString(s, "@type");
+      if (type === "UnitPriceSpecification" || type === "CompoundPriceSpecification") continue;
+      const description = getString(s, "name") || getString(s, "description");
+      if (!description) continue;
+      const discount2 = parsePrice(s["price"]);
+      promotions.push({
+        description,
+        discount_type: "fixed",
+        discount_value: discount2
+      });
+    }
+  }
+  const discount = offer["discount"];
+  if (typeof discount === "number" || typeof discount === "string") {
+    const val = typeof discount === "number" ? discount : parseFloat(discount);
+    if (!isNaN(val) && val > 0) {
+      promotions.push({
+        description: "Discount",
+        discount_type: "percentage",
+        discount_value: val
+      });
+    }
+  }
+  return promotions;
+}
+function extractPricePerUnit(offer) {
+  const priceSpec = offer["priceSpecification"];
+  if (!priceSpec) return void 0;
+  const specs = Array.isArray(priceSpec) ? priceSpec : [priceSpec];
+  for (const spec of specs) {
+    if (typeof spec !== "object" || spec === null) continue;
+    const s = spec;
+    if (getString(s, "@type") !== "UnitPriceSpecification") continue;
+    const amount = parsePrice(s["price"]);
+    const unit = getString(s, "unitText") || getString(s, "referenceQuantity") ? "unit" : void 0;
+    if (amount !== void 0 && unit) {
+      return { amount, unit: getString(s, "unitText") || "unit" };
+    }
+  }
+  return void 0;
+}
+function extractVariants(raw, sourceUrl) {
+  const variants = [];
+  const hasVariant = raw["hasVariant"];
+  if (Array.isArray(hasVariant)) {
+    for (const v of hasVariant) {
+      if (typeof v !== "object" || v === null) continue;
+      const variant = v;
+      const name = getString(variant, "name");
+      const sku = getString(variant, "sku");
+      const vOffers = getOffers(variant);
+      const vPrice = vOffers[0] ? parsePrice(vOffers[0]["price"]) : void 0;
+      if (name && vPrice !== void 0) {
+        const vResult = {
+          id: sku || generateIdFromUrl(sourceUrl) + "-" + variants.length,
+          name,
+          price: vPrice
+        };
+        if (vOffers[0]?.["availability"]) {
+          const avail = String(vOffers[0]["availability"]);
+          if (avail in AVAILABILITY_MAP) {
+            vResult.in_stock = AVAILABILITY_MAP[avail];
+          }
+        }
+        if (sku) vResult.sku = sku;
+        const attrs = {};
+        const color = getString(variant, "color");
+        if (color) attrs["color"] = color;
+        const size = getString(variant, "size");
+        if (size) attrs["size"] = size;
+        if (Object.keys(attrs).length > 0) vResult.attributes = attrs;
+        variants.push(vResult);
+      }
+    }
+  }
+  if (variants.length === 0) {
+    const offers = getOffers(raw);
+    if (offers.length > 1) {
+      for (let i = 0; i < offers.length; i++) {
+        const offer = offers[i];
+        const name = getString(offer, "name") || `Variant ${i + 1}`;
+        const sku = getString(offer, "sku");
+        const price = parsePrice(offer["price"]);
+        if (price !== void 0) {
+          const vResult = {
+            id: sku || `variant-${i}`,
+            name,
+            price
+          };
+          if (offer["availability"]) {
+            const avail = String(offer["availability"]);
+            if (avail in AVAILABILITY_MAP) {
+              vResult.in_stock = AVAILABILITY_MAP[avail];
+            }
+          }
+          if (sku) vResult.sku = sku;
+          variants.push(vResult);
+        }
+      }
+    }
+  }
+  return variants;
+}
+
+// src/utils/agent-notes.ts
+function generateAgentNotes(product) {
+  const parts = [];
+  const namePart = product.brand ? `${product.brand} ${product.name.toLowerCase()}` : product.name;
+  parts.push(namePart + ".");
+  if (product.category) {
+    parts.push(`Category: ${product.category}.`);
+  }
+  const attrs = product.attributes ?? {};
+  const rating = attrs["rating"];
+  const reviewCount = attrs["review_count"];
+  if (rating !== void 0) {
+    let ratingStr = `${rating}/5`;
+    if (reviewCount !== void 0) {
+      ratingStr += ` from ${reviewCount} reviews`;
+    }
+    parts.push(ratingStr + ".");
+  }
+  const highlights = [];
+  if (attrs["color"]) highlights.push(String(attrs["color"]));
+  if (attrs["material"]) highlights.push(String(attrs["material"]));
+  if (attrs["weight"]) highlights.push(String(attrs["weight"]));
+  if (highlights.length > 0) {
+    parts.push(highlights.join(", ") + ".");
+  }
+  if (product.variants && product.variants.length > 0) {
+    parts.push(`Available in ${product.variants.length} variants.`);
+  }
+  if (product.original_price && product.original_price > product.price) {
+    const discount = Math.round((1 - product.price / product.original_price) * 100);
+    parts.push(`${discount}% off (was ${product.currency} ${product.original_price.toFixed(2)}).`);
+  }
+  if (product.in_stock === true) {
+    parts.push("In stock.");
+  } else if (product.in_stock === false) {
+    parts.push("Out of stock.");
+  }
+  return parts.join(" ");
+}
+
+// src/utils/llmstxt.ts
+function parseLlmsTxt(content) {
+  const lines = content.split("\n");
+  let title;
+  let summary;
+  const sections = [];
+  const summaryLines = [];
+  let currentSection = null;
+  for (const line of lines) {
+    if (line.startsWith("# ") && !title) {
+      title = line.substring(2).trim();
+      continue;
+    }
+    if (line.startsWith(">")) {
+      summaryLines.push(line.substring(1).trim());
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      currentSection = {
+        heading: line.substring(3).trim(),
+        links: [],
+        rawLines: []
+      };
+      sections.push(currentSection);
+      continue;
+    }
+    if (currentSection && line.trim().startsWith("- [")) {
+      const linkMatch = /^-\s*\[([^\]]+)\]\(([^)]+)\)(?:\s*:\s*(.*))?/.exec(line.trim());
+      if (linkMatch) {
+        currentSection.links.push({
+          text: linkMatch[1],
+          url: linkMatch[2],
+          description: linkMatch[3]?.trim()
+        });
+      }
+      currentSection.rawLines.push(line);
+      continue;
+    }
+    if (currentSection && line.trim()) {
+      currentSection.rawLines.push(line);
+    }
+  }
+  if (summaryLines.length > 0) {
+    summary = summaryLines.join(" ");
+  }
+  return { title, summary, sections, raw: content };
+}
+function generateCommerceSection(data) {
+  const lines = ["## Commerce"];
+  if (data.manifestUrl) {
+    lines.push(`- [Store Manifest](${data.manifestUrl}): Machine-readable commerce capabilities and product feed location`);
+  }
+  if (data.feedUrl) {
+    let desc = "Full product catalog (JSONL";
+    if (data.productCount !== void 0) {
+      desc += `, ${data.productCount} products`;
+    }
+    if (data.updateFrequency) {
+      desc += `, ${data.updateFrequency}`;
+    }
+    desc += ")";
+    lines.push(`- [Product Catalog](${data.feedUrl}): ${desc}`);
+  }
+  if (data.ocpMdUrl) {
+    lines.push(`- [Agent Storefront](${data.ocpMdUrl}): Store overview, policies, and categories for AI agent context`);
+  }
+  return lines.join("\n");
+}
+function patchLlmsTxt(content, data) {
+  const parsed = parseLlmsTxt(content);
+  const commerceSection = generateCommerceSection(data);
+  const existingIdx = parsed.sections.findIndex(
+    (s) => s.heading.toLowerCase() === "commerce"
+  );
+  const lines = content.split("\n");
+  if (existingIdx >= 0) {
+    const section = parsed.sections[existingIdx];
+    const startLine = findSectionLine(lines, section.heading);
+    if (startLine >= 0) {
+      const endLine = findNextSectionLine(lines, startLine + 1);
+      const newLines = commerceSection.split("\n");
+      lines.splice(startLine, endLine - startLine, ...newLines);
+      return lines.join("\n");
+    }
+  }
+  const optionalIdx = parsed.sections.findIndex(
+    (s) => s.heading.toLowerCase() === "optional"
+  );
+  if (optionalIdx >= 0) {
+    const section = parsed.sections[optionalIdx];
+    const startLine = findSectionLine(lines, section.heading);
+    if (startLine >= 0) {
+      lines.splice(startLine, 0, "", commerceSection, "");
+      return lines.join("\n");
+    }
+  }
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + commerceSection + "\n";
+}
+function generateLlmsTxt(storeName, storeDescription, data) {
+  const lines = [
+    `# ${storeName}`,
+    "",
+    `> ${storeDescription}`,
+    "",
+    generateCommerceSection(data),
+    ""
+  ];
+  return lines.join("\n");
+}
+function findSectionLine(lines, heading) {
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === `## ${heading}`) {
+      return i;
+    }
+  }
+  return -1;
+}
+function findNextSectionLine(lines, startLine) {
+  for (let i = startLine; i < lines.length; i++) {
+    if (lines[i].startsWith("## ")) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+
+// src/commands/crawl.ts
+async function runCrawl(url, options) {
+  const { default: ora } = await import("ora");
+  const baseUrl = url.replace(/\/$/, "");
+  console.log(import_chalk5.default.bold.cyan("\n\u{1F577}  OCP Crawl \u2014 Schema.org Product Extraction\n"));
+  console.log(import_chalk5.default.dim(`Target: ${baseUrl}`));
+  console.log(import_chalk5.default.dim(`Output: ${options.output}`));
+  console.log();
+  const client = new HttpClient({
+    userAgent: options.userAgent,
+    minDelay: options.delay
+  });
+  const spinner = ora("Fetching robots.txt...").start();
+  let robots;
+  let existingManifestUrl;
+  try {
+    const robotsRes = await client.get(`${baseUrl}/robots.txt`);
+    if (robotsRes.ok) {
+      robots = parseRobotsTxt(robotsRes.text);
+      existingManifestUrl = robots.ocpManifest;
+      const crawlDelay = getCrawlDelay(robots, "OCPBot");
+      if (crawlDelay) {
+        const delayMs = Math.max(crawlDelay * 1e3, options.delay);
+        client.setMinDelay(delayMs);
+        spinner.text = `robots.txt found (Crawl-delay: ${crawlDelay}s)`;
+      }
+      spinner.succeed(`robots.txt found (${robots.sitemaps.length} sitemaps${existingManifestUrl ? ", OCP-Manifest detected" : ""})`);
+    } else {
+      spinner.info("No robots.txt found \u2014 proceeding with defaults");
+    }
+  } catch {
+    spinner.info("Could not fetch robots.txt \u2014 proceeding with defaults");
+  }
+  const sitemapSpinner = ora("Fetching sitemap...").start();
+  let allSitemapUrls = [];
+  const sitemapUrls = robots?.sitemaps?.length ? robots.sitemaps : [`${baseUrl}/sitemap.xml`];
+  for (const sitemapUrl of sitemapUrls) {
+    try {
+      const urls = await fetchSitemap(sitemapUrl, client);
+      allSitemapUrls.push(...urls);
+    } catch {
+      if (options.verbose) {
+        console.log(import_chalk5.default.dim(`  Could not fetch sitemap: ${sitemapUrl}`));
+      }
+    }
+  }
+  if (allSitemapUrls.length === 0) {
+    sitemapSpinner.warn("No sitemap found \u2014 cannot discover product URLs");
+    console.log(import_chalk5.default.yellow("  Try providing a sitemap URL or use --product-pattern to specify URL patterns"));
+    return;
+  }
+  sitemapSpinner.succeed(`Found ${allSitemapUrls.length} URLs in sitemap(s)`);
+  const productPattern = options.productPattern ? new RegExp(options.productPattern, "i") : void 0;
+  let productUrls = filterProductUrls(allSitemapUrls, productPattern);
+  if (robots) {
+    productUrls = productUrls.filter((u) => {
+      try {
+        const urlPath = new URL(u.loc).pathname;
+        return isPathAllowed(robots, urlPath, "OCPBot");
+      } catch {
+        return true;
+      }
+    });
+  }
+  if (options.maxProducts) {
+    productUrls = productUrls.slice(0, options.maxProducts);
+  }
+  console.log(import_chalk5.default.dim(`Identified ${productUrls.length} product URLs to crawl`));
+  if (productUrls.length === 0) {
+    console.log(import_chalk5.default.yellow("\nNo product URLs found. Try using --product-pattern to specify URL patterns."));
+    return;
+  }
+  if (options.dryRun) {
+    console.log(import_chalk5.default.bold("\nDry run \u2014 URLs that would be crawled:"));
+    for (const u of productUrls) {
+      console.log(`  ${u.loc}`);
+    }
+    console.log(import_chalk5.default.dim(`
+Total: ${productUrls.length} URLs`));
+    return;
+  }
+  let startIndex = 0;
+  let products = [];
+  const statePath = import_path4.default.join(options.output, ".ocp-crawl-state.json");
+  if (options.resume) {
+    try {
+      const stateRaw = await import_fs4.promises.readFile(statePath, "utf-8");
+      const state = JSON.parse(stateRaw);
+      startIndex = state.lastCrawledIndex + 1;
+      products = state.products;
+      console.log(import_chalk5.default.dim(`Resuming from URL ${startIndex + 1}/${productUrls.length}`));
+    } catch {
+    }
+  }
+  let extracted = products.length;
+  let failed = 0;
+  let siteTitle;
+  let siteDescription;
+  const crawlSpinner = ora(`Crawling products... 0/${productUrls.length}`).start();
+  const urlList = productUrls.map((u) => u.loc);
+  for (let i = startIndex; i < urlList.length; i += options.concurrency) {
+    const batch = urlList.slice(i, i + options.concurrency);
+    const results = await Promise.allSettled(
+      batch.map(async (productUrl) => {
+        const response = await client.get(productUrl);
+        if (!response.ok) return null;
+        if (!siteTitle) {
+          const meta = extractPageMetadata(response.text);
+          if (meta.title) siteTitle = meta.title;
+          if (meta.description) siteDescription = meta.description;
+        }
+        const schemaProducts = extractProductsFromHtml(response.text, productUrl);
+        return schemaProducts;
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value) {
+        for (const sp of result.value) {
+          const ocpProduct = mapSchemaOrgToOCP(sp);
+          if (ocpProduct) {
+            if (options.generateAgentNotes && !ocpProduct.agent_notes) {
+              ocpProduct.agent_notes = generateAgentNotes(ocpProduct);
+            }
+            products.push(ocpProduct);
+            extracted++;
+          } else {
+            failed++;
+          }
+        }
+        if (result.value.length === 0) failed++;
+      } else {
+        failed++;
+      }
+    }
+    crawlSpinner.text = `Crawling products... ${Math.min(i + options.concurrency, urlList.length)}/${urlList.length} (${extracted} extracted)`;
+    if (i % 50 === 0 && i > 0) {
+      await import_fs4.promises.mkdir(options.output, { recursive: true });
+      const state = {
+        lastCrawledIndex: i + batch.length - 1,
+        productUrls: urlList,
+        products
+      };
+      await import_fs4.promises.writeFile(statePath, JSON.stringify(state), "utf-8");
+    }
+  }
+  crawlSpinner.succeed(`Crawled ${urlList.length} URLs. Extracted ${extracted} products. ${failed} pages had no Product JSON-LD.`);
+  const outputSpinner = ora("Generating output files...").start();
+  const outputDir = options.output;
+  const wellKnownDir = import_path4.default.join(outputDir, ".well-known");
+  const ocpDir = import_path4.default.join(outputDir, "ocp");
+  await import_fs4.promises.mkdir(wellKnownDir, { recursive: true });
+  await import_fs4.promises.mkdir(ocpDir, { recursive: true });
+  const feedPath = import_path4.default.join(ocpDir, "products.jsonl");
+  await import_fs4.promises.writeFile(feedPath, products.map((p) => JSON.stringify(p)).join("\n") + "\n", "utf-8");
+  const storeName = siteTitle?.replace(/ [-|–].*/g, "").trim() || new URL(baseUrl).hostname;
+  const manifest = {
+    version: import_spec3.OCP_VERSION,
+    merchant: {
+      name: storeName,
+      url: baseUrl
+    },
+    capabilities: {
+      catalog: true,
+      search: true
+    },
+    discovery: {
+      feed: `${baseUrl}/ocp/products.jsonl`,
+      feed_format: "jsonl",
+      feed_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      feed_generated_from: "schema_org_crawl",
+      sitemap: sitemapUrls[0],
+      total_products: products.length,
+      schema_org: true,
+      robots_txt: false,
+      llms_txt: false
+    },
+    permissions: {
+      requires_human_checkout: true
+    }
+  };
+  const manifestPath = import_path4.default.join(wellKnownDir, "ocp.json");
+  await import_fs4.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  const categories = [...new Set(products.filter((p) => p.category).map((p) => p.category))];
+  const priceRange = products.length > 0 ? { min: Math.min(...products.map((p) => p.price)), max: Math.max(...products.map((p) => p.price)) } : { min: 0, max: 0 };
+  const ocpMdContent = generateOcpMd2(storeName, baseUrl, siteDescription, categories, products.length, priceRange, products[0]?.currency || "USD");
+  await import_fs4.promises.writeFile(import_path4.default.join(outputDir, "ocp.md"), ocpMdContent, "utf-8");
+  const robotsTxtPath = import_path4.default.join(outputDir, "robots.txt");
+  const manifestUrl = `${baseUrl}/.well-known/ocp.json`;
+  try {
+    const existingRobots = await import_fs4.promises.readFile(robotsTxtPath, "utf-8");
+    const patchedRobots = patchRobotsTxt(existingRobots, manifestUrl);
+    await import_fs4.promises.writeFile(robotsTxtPath, patchedRobots, "utf-8");
+  } catch {
+    const newRobots = `User-agent: *
+Allow: /
+
+Sitemap: ${baseUrl}/sitemap.xml
+OCP-Manifest: ${manifestUrl}
+`;
+    await import_fs4.promises.writeFile(robotsTxtPath, newRobots, "utf-8");
+  }
+  manifest.discovery["robots_txt"] = true;
+  const llmsTxtPath = import_path4.default.join(outputDir, "llms.txt");
+  const commerceData = {
+    manifestUrl: "/.well-known/ocp.json",
+    feedUrl: "/ocp/products.jsonl",
+    ocpMdUrl: "/ocp.md",
+    productCount: products.length,
+    updateFrequency: "updated daily"
+  };
+  try {
+    const existingLlms = await import_fs4.promises.readFile(llmsTxtPath, "utf-8");
+    const patchedLlms = patchLlmsTxt(existingLlms, commerceData);
+    await import_fs4.promises.writeFile(llmsTxtPath, patchedLlms, "utf-8");
+  } catch {
+    const newLlms = generateLlmsTxt(storeName, siteDescription || `Online store at ${baseUrl}`, commerceData);
+    await import_fs4.promises.writeFile(llmsTxtPath, newLlms, "utf-8");
+  }
+  manifest.discovery["llms_txt"] = true;
+  await import_fs4.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  try {
+    await import_fs4.promises.unlink(statePath);
+  } catch {
+  }
+  outputSpinner.succeed("Output files generated");
+  const capCount = Object.values(manifest.capabilities ?? {}).filter((v) => v === true || typeof v === "string" && v !== "none").length;
+  console.log(`
+${import_chalk5.default.bold("OCP Discovery Setup Complete")}
+${import_chalk5.default.dim("\u2550".repeat(55))}
+${import_chalk5.default.bold("Store:")}     ${storeName} (${baseUrl})
+${import_chalk5.default.bold("Products:")}  ${products.length} extracted from ${urlList.length} crawled URLs
+
+${import_chalk5.default.bold("Generated files:")}
+  .well-known/ocp.json     ${import_chalk5.default.green("\u2713")}  Manifest (${capCount} capabilities)
+  ocp/products.jsonl        ${import_chalk5.default.green("\u2713")}  Product feed (${products.length} products)
+  ocp.md                    ${import_chalk5.default.green("\u2713")}  Agent storefront context
+  robots.txt                ${import_chalk5.default.green("\u2713")}  OCP-Manifest directive added
+  llms.txt                  ${import_chalk5.default.green("\u2713")}  Commerce section added
+
+${import_chalk5.default.bold("Next steps:")}
+  1. Review generated files in ${import_chalk5.default.cyan(options.output + "/")}
+  2. Upload to your web root
+  3. Verify: ${import_chalk5.default.cyan(`npx @opencommerceprotocol/cli validate ${baseUrl}`)}
+${import_chalk5.default.dim("\u2550".repeat(55))}
+`);
+}
+function generateOcpMd2(storeName, storeUrl, description, categories, productCount, priceRange, currency) {
+  return `# ${storeName} \u2014 Open Commerce Protocol
+
+## About This Store
+
+${description || `${storeName} is an online store located at ${storeUrl}.`}
+
+## Catalog Overview
+
+- **Total Products:** ${productCount}
+- **Price Range:** ${currency} ${priceRange.min.toFixed(2)} \u2013 ${currency} ${priceRange.max.toFixed(2)}
+${categories.length > 0 ? `- **Categories:** ${categories.slice(0, 20).join(", ")}${categories.length > 20 ? ` (+${categories.length - 20} more)` : ""}` : ""}
+
+## How to Shop
+
+1. Use \`search_products\` to find products by keyword or category
+2. Use \`get_product\` to get detailed information on a specific item
+3. Use \`add_to_cart\` to add items to the cart
+4. Use \`begin_checkout\` to proceed to checkout (a human must complete payment)
+
+## Policies
+
+- All purchases require human confirmation at checkout
+- Product availability is updated in real-time
+
+## Machine-Readable Resources
+
+- Full llms.txt: /llms.txt
+- Commerce manifest: /.well-known/ocp.json
+- Product feed: /ocp/products.jsonl
+- robots.txt OCP directive: present
+
+*This document is optimized for AI agents. For the human-readable store, visit ${storeUrl}*
+`;
+}
+
+// src/commands/robots.ts
+var import_fs5 = require("fs");
+var import_path5 = __toESM(require("path"));
+var import_chalk6 = __toESM(require("chalk"));
+async function runRobots(filePath, options) {
+  const robotsPath = filePath ? import_path5.default.resolve(filePath) : import_path5.default.resolve("robots.txt");
+  let manifestUrl = options.url || "/.well-known/ocp.json";
+  if (!options.url) {
+    try {
+      const manifestPath = import_path5.default.resolve(import_path5.default.dirname(robotsPath), ".well-known", "ocp.json");
+      const manifestRaw = await import_fs5.promises.readFile(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestRaw);
+      if (manifest.merchant?.url) {
+        manifestUrl = `${manifest.merchant.url.replace(/\/$/, "")}/.well-known/ocp.json`;
+      }
+    } catch {
+    }
+  }
+  let content = "";
+  let existed = false;
+  try {
+    content = await import_fs5.promises.readFile(robotsPath, "utf-8");
+    existed = true;
+  } catch {
+  }
+  const parsed = parseRobotsTxt(content);
+  if (parsed.ocpManifest) {
+    console.log(import_chalk6.default.green("\u2713 robots.txt already contains OCP-Manifest directive"));
+    console.log(import_chalk6.default.dim(`  OCP-Manifest: ${parsed.ocpManifest}`));
+    return;
+  }
+  const patched = patchRobotsTxt(content, manifestUrl);
+  if (options.stdout) {
+    console.log(patched);
+    return;
+  }
+  await import_fs5.promises.writeFile(robotsPath, patched, "utf-8");
+  if (existed) {
+    console.log(import_chalk6.default.green("\u2713 Updated robots.txt with OCP-Manifest directive"));
+  } else {
+    console.log(import_chalk6.default.green("\u2713 Created robots.txt with OCP-Manifest directive"));
+  }
+  console.log(import_chalk6.default.dim(`  Added: OCP-Manifest: ${manifestUrl}`));
+}
+
+// src/commands/llms.ts
+var import_fs6 = require("fs");
+var import_path6 = __toESM(require("path"));
+var import_chalk7 = __toESM(require("chalk"));
+async function runLlms(filePath, options) {
+  const llmsPath = filePath ? import_path6.default.resolve(filePath) : import_path6.default.resolve("llms.txt");
+  const dir = import_path6.default.dirname(llmsPath);
+  let manifest;
+  try {
+    const manifestPath = import_path6.default.resolve(dir, ".well-known", "ocp.json");
+    const manifestRaw = await import_fs6.promises.readFile(manifestPath, "utf-8");
+    manifest = JSON.parse(manifestRaw);
+  } catch {
+    try {
+      const manifestPath = import_path6.default.resolve(".well-known", "ocp.json");
+      const manifestRaw = await import_fs6.promises.readFile(manifestPath, "utf-8");
+      manifest = JSON.parse(manifestRaw);
+    } catch {
+    }
+  }
+  const commerceData = {
+    manifestUrl: "/.well-known/ocp.json",
+    feedUrl: manifest?.discovery?.feed ? new URL(manifest.discovery.feed).pathname : "/ocp/products.jsonl",
+    ocpMdUrl: "/ocp.md",
+    productCount: manifest?.discovery?.total_products
+  };
+  let existingContent;
+  try {
+    existingContent = await import_fs6.promises.readFile(llmsPath, "utf-8");
+  } catch {
+  }
+  let result;
+  if (existingContent) {
+    const parsed = parseLlmsTxt(existingContent);
+    const hasCommerce = parsed.sections.some((s) => s.heading.toLowerCase() === "commerce");
+    result = patchLlmsTxt(existingContent, commerceData);
+    if (options.stdout) {
+      console.log(result);
+      return;
+    }
+    await import_fs6.promises.writeFile(llmsPath, result, "utf-8");
+    if (hasCommerce) {
+      console.log(import_chalk7.default.green("\u2713 Updated ## Commerce section in llms.txt"));
+    } else {
+      console.log(import_chalk7.default.green("\u2713 Added ## Commerce section to llms.txt"));
+    }
+  } else {
+    let storeDescription = "";
+    try {
+      const ocpMd = await import_fs6.promises.readFile(import_path6.default.resolve(dir, "ocp.md"), "utf-8");
+      const lines = ocpMd.split("\n");
+      let foundHeading = false;
+      for (const line of lines) {
+        if (line.startsWith("#")) {
+          if (foundHeading) break;
+          foundHeading = true;
+          continue;
+        }
+        if (foundHeading && line.trim()) {
+          storeDescription = line.trim();
+          break;
+        }
+      }
+    } catch {
+    }
+    const storeName = manifest?.merchant?.name || "My Store";
+    storeDescription = storeDescription || `Online store at ${manifest?.merchant?.url || "https://mystore.com"}`;
+    result = generateLlmsTxt(storeName, storeDescription, commerceData);
+    if (options.stdout) {
+      console.log(result);
+      return;
+    }
+    await import_fs6.promises.writeFile(llmsPath, result, "utf-8");
+    console.log(import_chalk7.default.green("\u2713 Generated llms.txt with ## Commerce section"));
+  }
+  if (options.full && manifest?.discovery?.feed) {
+    try {
+      const feedPath = import_path6.default.resolve(dir, "ocp", "products.jsonl");
+      const feedRaw = await import_fs6.promises.readFile(feedPath, "utf-8");
+      const products = feedRaw.split("\n").filter((l) => l.trim()).map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      if (products.length > 500) {
+        console.log(import_chalk7.default.yellow(`\u26A0 Catalog has ${products.length} products \u2014 llms-full.txt is capped at 500. Use JSONL feed for full catalog.`));
+      }
+      const fullProducts = products.slice(0, 500);
+      let fullContent = result + "\n\n## Products\n\n";
+      for (const p of fullProducts) {
+        fullContent += `### ${p["name"]}
+`;
+        if (p["description"]) fullContent += `${p["description"]}
+`;
+        fullContent += `- Price: ${p["currency"]} ${p["price"]}
+`;
+        if (p["category"]) fullContent += `- Category: ${p["category"]}
+`;
+        if (p["in_stock"] !== void 0) fullContent += `- In Stock: ${p["in_stock"] ? "Yes" : "No"}
+`;
+        if (p["url"]) fullContent += `- URL: ${p["url"]}
+`;
+        fullContent += "\n";
+      }
+      const fullPath = import_path6.default.resolve(dir, "llms-full.txt");
+      await import_fs6.promises.writeFile(fullPath, fullContent, "utf-8");
+      console.log(import_chalk7.default.green(`\u2713 Generated llms-full.txt (${fullProducts.length} products)`));
+    } catch {
+      console.log(import_chalk7.default.yellow("\u26A0 Could not generate llms-full.txt \u2014 product feed not found"));
+    }
+  }
+  console.log(import_chalk7.default.dim(`  File: ${llmsPath}`));
+}
+
+// src/commands/stats.ts
+var import_chalk8 = __toESM(require("chalk"));
+var import_fs7 = require("fs");
+var AGENT_UA_PATTERNS = [
+  /GPTBot/i,
+  /Claude-Web/i,
+  /anthropic/i,
+  /OpenAI/i,
+  /Google-Extended/i,
+  /Googlebot/i,
+  /Bingbot/i,
+  /OCPBot/i,
+  /PerplexityBot/i,
+  /YouBot/i,
+  /CCBot/i,
+  /ChatGPT/i,
+  /cohere-ai/i
+];
+var OCP_PATH_PATTERNS = {
+  manifest: /\/.well-known\/ocp\.json/,
+  feed: /\/ocp\/products\.jsonl/,
+  ocpMd: /\/ocp\.md/,
+  toolCall: /\/ocp\/(search|product|cart|checkout)/i
+};
+function isAgentUA(ua) {
+  return AGENT_UA_PATTERNS.some((p) => p.test(ua));
+}
+function parseNginxLine(line) {
+  const match = line.match(
+    /^\S+ \S+ \S+ \[[^\]]+\] "(?:GET|POST|HEAD|PUT|DELETE|OPTIONS|PATCH) ([^ "]+)[^"]*" (\d+) \d+(?:\s+"[^"]*"\s+"([^"]*)")?/
+  );
+  if (!match) return null;
+  return {
+    path: match[1] ?? "/",
+    status: parseInt(match[2] ?? "0", 10),
+    ua: match[3] ?? ""
+  };
+}
+function parseApacheLine(line) {
+  return parseNginxLine(line);
+}
+function parseCloudflareLine(line, headerMap) {
+  if (Object.keys(headerMap).length === 0) return null;
+  const fields = splitCsvLine(line);
+  const uriIdx = headerMap["ClientRequestURI"] ?? headerMap["ClientRequestPath"];
+  const uaIdx = headerMap["ClientRequestUserAgent"];
+  const statusIdx = headerMap["EdgeResponseStatus"] ?? headerMap["CacheResponseStatus"];
+  if (uriIdx === void 0 || uaIdx === void 0) return null;
+  const path7 = fields[uriIdx] ?? "/";
+  const ua = fields[uaIdx] ?? "";
+  const status = statusIdx !== void 0 ? parseInt(fields[statusIdx] ?? "0", 10) : 200;
+  return { path: path7.split("?")[0] ?? path7, ua, status };
+}
+function splitCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === "," && !inQuotes) {
+      fields.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function analyzeLines(lines, format) {
+  const stats = {
+    totalRequests: 0,
+    manifestRequests: 0,
+    feedRequests: 0,
+    toolCallRequests: 0,
+    agentUserAgents: {},
+    topPaths: [],
+    conversionFunnel: {
+      manifestViews: 0,
+      feedLoads: 0,
+      productViews: 0,
+      cartAdds: 0,
+      checkouts: 0
+    }
+  };
+  const pathCounts = {};
+  const cloudflareHeaderMap = {};
+  let cloudflareHeaderParsed = false;
+  const parseLine = (line) => {
+    if (format === "cloudflare") {
+      if (!cloudflareHeaderParsed) {
+        const cols = splitCsvLine(line);
+        cols.forEach((col, idx) => {
+          cloudflareHeaderMap[col.trim()] = idx;
+        });
+        cloudflareHeaderParsed = true;
+        return null;
+      }
+      return parseCloudflareLine(line, cloudflareHeaderMap);
+    }
+    return format === "apache" ? parseApacheLine(line) : parseNginxLine(line);
+  };
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const parsed = parseLine(line);
+    if (!parsed) continue;
+    const { path: path7, ua } = parsed;
+    if (OCP_PATH_PATTERNS.manifest.test(path7)) {
+      stats.manifestRequests++;
+      stats.conversionFunnel.manifestViews++;
+      stats.totalRequests++;
+    } else if (OCP_PATH_PATTERNS.feed.test(path7)) {
+      stats.feedRequests++;
+      stats.conversionFunnel.feedLoads++;
+      stats.totalRequests++;
+    } else if (OCP_PATH_PATTERNS.toolCall.test(path7)) {
+      stats.toolCallRequests++;
+      stats.totalRequests++;
+      if (/\/ocp\/product/i.test(path7)) stats.conversionFunnel.productViews++;
+      if (/\/ocp\/cart/i.test(path7)) stats.conversionFunnel.cartAdds++;
+      if (/\/ocp\/checkout/i.test(path7)) stats.conversionFunnel.checkouts++;
+    } else if (OCP_PATH_PATTERNS.ocpMd.test(path7)) {
+      stats.totalRequests++;
+    }
+    if (isAgentUA(ua)) {
+      const agentName = extractAgentName(ua);
+      stats.agentUserAgents[agentName] = (stats.agentUserAgents[agentName] ?? 0) + 1;
+    }
+    pathCounts[path7] = (pathCounts[path7] ?? 0) + 1;
+  }
+  stats.topPaths = Object.entries(pathCounts).filter(([p]) => p.startsWith("/ocp") || p.includes("ocp.json") || p.includes("ocp.md")).sort(([, a], [, b]) => b - a).slice(0, 10).map(([path7, count]) => ({ path: path7, count }));
+  return stats;
+}
+function extractAgentName(ua) {
+  for (const pattern of AGENT_UA_PATTERNS) {
+    const m = ua.match(pattern);
+    if (m) return m[0];
+  }
+  return "Unknown Agent";
+}
+function printStats(stats, sourceLabel) {
+  console.log("\n" + import_chalk8.default.bold("OCP Agent Traffic Report"));
+  console.log(import_chalk8.default.dim("\u2501".repeat(50)));
+  console.log(import_chalk8.default.bold("Source:"), sourceLabel);
+  console.log();
+  console.log(import_chalk8.default.bold("OCP Request Summary"));
+  console.log(`  Manifest requests:   ${import_chalk8.default.cyan(String(stats.manifestRequests))}`);
+  console.log(`  Feed loads:          ${import_chalk8.default.cyan(String(stats.feedRequests))}`);
+  console.log(`  Tool calls:          ${import_chalk8.default.cyan(String(stats.toolCallRequests))}`);
+  console.log(`  Total OCP requests:  ${import_chalk8.default.cyan(String(stats.totalRequests))}`);
+  if (Object.keys(stats.agentUserAgents).length > 0) {
+    console.log();
+    console.log(import_chalk8.default.bold("AI Agents Detected"));
+    const sorted = Object.entries(stats.agentUserAgents).sort(([, a], [, b]) => b - a);
+    for (const [agent, count] of sorted.slice(0, 10)) {
+      console.log(`  ${import_chalk8.default.green(agent.padEnd(25))} ${count} requests`);
+    }
+  }
+  console.log();
+  console.log(import_chalk8.default.bold("Conversion Funnel"));
+  const f = stats.conversionFunnel;
+  const funnel = [
+    ["Manifest viewed", f.manifestViews],
+    ["Feed loaded", f.feedLoads],
+    ["Product viewed", f.productViews],
+    ["Cart add", f.cartAdds],
+    ["Checkout started", f.checkouts]
+  ];
+  for (const [label, count] of funnel) {
+    const pct = f.manifestViews > 0 ? Math.round(count / f.manifestViews * 100) : 0;
+    const bar = "\u2588".repeat(Math.max(1, Math.round(pct / 5)));
+    console.log(`  ${label.padEnd(20)} ${String(count).padStart(6)}  ${import_chalk8.default.dim(bar)} ${pct}%`);
+  }
+  if (stats.topPaths.length > 0) {
+    console.log();
+    console.log(import_chalk8.default.bold("Top OCP Paths"));
+    for (const { path: path7, count } of stats.topPaths) {
+      console.log(`  ${String(count).padStart(6)}  ${import_chalk8.default.cyan(path7)}`);
+    }
+  }
+  console.log();
+  if (stats.totalRequests === 0) {
+    console.log(import_chalk8.default.yellow("No OCP traffic detected in logs."));
+    console.log(import_chalk8.default.dim("Tip: Ensure your log file covers OCP paths (/.well-known/ocp.json, /ocp/)"));
+  } else {
+    console.log(import_chalk8.default.green(`\u2713 ${stats.totalRequests} OCP requests found across ${Object.keys(stats.agentUserAgents).length} agent types.`));
+  }
+  console.log();
+}
+async function runStats(url, options) {
+  const format = options.format ?? "nginx";
+  if (options.log) {
+    let content;
+    try {
+      content = await import_fs7.promises.readFile(options.log, "utf-8");
+    } catch {
+      console.error(import_chalk8.default.red(`Error: Cannot read log file: ${options.log}`));
+      process.exit(1);
+    }
+    const lines = content.split("\n");
+    const stats = analyzeLines(lines, format);
+    printStats(stats, options.log);
+    return;
+  }
+  console.log("\n" + import_chalk8.default.bold("OCP Stats \u2014 Log Analysis"));
+  console.log(import_chalk8.default.dim("\u2501".repeat(50)));
+  console.log();
+  console.log("Analyze your server access logs for OCP agent traffic:");
+  console.log();
+  console.log(import_chalk8.default.cyan("  # Nginx"));
+  console.log("  npx @opencommerceprotocol/cli stats --log /var/log/nginx/access.log");
+  console.log();
+  console.log(import_chalk8.default.cyan("  # Apache"));
+  console.log("  npx @opencommerceprotocol/cli stats --log /var/log/apache2/access.log --format apache");
+  console.log();
+  console.log(import_chalk8.default.cyan("  # Cloudflare (export CSV from dashboard first)"));
+  console.log("  npx @opencommerceprotocol/cli stats --log cloudflare-export.csv --format cloudflare");
+  console.log();
+  console.log(import_chalk8.default.dim("What you'll see:"));
+  console.log("  - Which AI agents are visiting your store");
+  console.log("  - How many times your manifest and feed are fetched");
+  console.log("  - Conversion funnel from discovery to checkout");
+  console.log();
+  if (url) {
+    console.log(import_chalk8.default.yellow(`Tip: Use npx @opencommerceprotocol/cli test-agent ${url} to simulate an agent visit.`));
+  }
+}
+
+// src/commands/test-agent.ts
+var import_chalk9 = __toESM(require("chalk"));
+var import_validator2 = require("@opencommerceprotocol/validator");
+function formatCheck(result) {
+  const icon = result.passed ? import_chalk9.default.green("  \u2713") : import_chalk9.default.red("  \u2717");
+  console.log(`${icon} ${result.name}`);
+  if (result.message) {
+    const color = result.passed ? import_chalk9.default.dim : import_chalk9.default.yellow;
+    console.log(`    ${color(result.message)}`);
+  }
+  if (result.detail && !result.passed) {
+    console.log(`    ${import_chalk9.default.dim(result.detail)}`);
+  }
+}
+async function runTestAgent(url, options) {
+  const baseUrl = url.replace(/\/$/, "");
+  const testQuery = options.query ?? "product";
+  console.log("\n" + import_chalk9.default.bold("OCP Agent Simulation"));
+  console.log(import_chalk9.default.dim("\u2501".repeat(50)));
+  console.log(import_chalk9.default.bold("Target:"), baseUrl);
+  console.log(import_chalk9.default.bold("Test query:"), `"${testQuery}"`);
+  console.log();
+  const allResults = [];
+  let manifest = null;
+  let feedUrl = null;
+  let firstProduct = null;
+  console.log(import_chalk9.default.bold("Step 1: Fetching manifest"));
+  const step1 = [];
+  try {
+    const res = await fetch(`${baseUrl}/.well-known/ocp.json`);
+    if (!res.ok) {
+      step1.push({
+        name: "Manifest accessible",
+        passed: false,
+        message: `HTTP ${res.status} \u2014 manifest not found`,
+        detail: "Agents cannot discover this store. Run: npx @opencommerceprotocol/cli init"
+      });
+    } else {
+      manifest = await res.json();
+      step1.push({
+        name: "Manifest accessible",
+        passed: true,
+        message: `Found /.well-known/ocp.json`
+      });
+      const hasVersion = Boolean(manifest["version"]);
+      const hasMerchant = Boolean(manifest["merchant"]);
+      const hasDiscovery = Boolean(manifest["discovery"]);
+      step1.push({
+        name: "Manifest has required fields",
+        passed: hasVersion && hasMerchant,
+        message: hasVersion && hasMerchant ? `version: ${manifest["version"]}, merchant: ${manifest["merchant"]?.["name"]}` : "Missing required fields: version, merchant"
+      });
+      step1.push({
+        name: "Manifest has discovery config",
+        passed: hasDiscovery,
+        message: hasDiscovery ? "discovery section present" : "No discovery section \u2014 agents cannot find your product feed"
+      });
+      if (hasDiscovery) {
+        const discovery = manifest["discovery"];
+        feedUrl = discovery["feed"] ?? `${baseUrl}/ocp/products.jsonl`;
+        if (discovery["feed_updated"]) {
+          const updatedAt = new Date(discovery["feed_updated"]);
+          const ageHours = (Date.now() - updatedAt.getTime()) / 1e3 / 3600;
+          step1.push({
+            name: "Feed freshness (feed_updated)",
+            passed: ageHours < 48,
+            message: ageHours < 1 ? "Feed updated recently (< 1 hour ago)" : ageHours < 24 ? `Feed updated ${Math.round(ageHours)} hours ago` : `Feed is ${Math.round(ageHours / 24)} days old \u2014 consider more frequent updates`
+          });
+        } else {
+          step1.push({
+            name: "Feed freshness (feed_updated)",
+            passed: false,
+            message: "feed_updated not set \u2014 agents cannot assess data freshness",
+            detail: 'Add feed_updated: "<ISO-timestamp>" to your discovery config'
+          });
+        }
+      }
+    }
+  } catch (err) {
+    step1.push({
+      name: "Manifest accessible",
+      passed: false,
+      message: `Network error: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  for (const r of step1) {
+    formatCheck(r);
+    allResults.push(r);
+  }
+  console.log();
+  console.log(import_chalk9.default.bold("Step 2: Loading product feed"));
+  const step2 = [];
+  const effectiveFeedUrl = feedUrl ?? `${baseUrl}/ocp/products.jsonl`;
+  const products = [];
+  try {
+    const res = await fetch(effectiveFeedUrl);
+    if (!res.ok) {
+      step2.push({
+        name: "Product feed accessible",
+        passed: false,
+        message: `HTTP ${res.status} at ${effectiveFeedUrl}`,
+        detail: "Run: npx @opencommerceprotocol/cli generate --products products.csv"
+      });
+    } else {
+      const text = await res.text();
+      const lines = text.split("\n").filter((l) => l.trim()).slice(0, 1e3);
+      let validCount = 0;
+      let invalidCount = 0;
+      let withNotesCount = 0;
+      const parseErrors = [];
+      for (const line of lines) {
+        try {
+          const p = JSON.parse(line);
+          if (p["id"] && p["name"] && p["price"] !== void 0) {
+            validCount++;
+            if (!firstProduct) firstProduct = p;
+          } else {
+            invalidCount++;
+          }
+          if (p["agent_notes"]) withNotesCount++;
+          products.push(p);
+        } catch {
+          invalidCount++;
+          if (parseErrors.length < 3) parseErrors.push(line.slice(0, 60));
+        }
+      }
+      step2.push({
+        name: "Product feed accessible",
+        passed: true,
+        message: `${lines.length} products found at ${effectiveFeedUrl}`
+      });
+      step2.push({
+        name: "Products are valid",
+        passed: invalidCount === 0,
+        message: invalidCount === 0 ? `All ${validCount} products have required fields (id, name, price)` : `${invalidCount} invalid products (missing id, name, or price)`,
+        detail: parseErrors.length > 0 ? `Parse errors: ${parseErrors.join(", ")}` : void 0
+      });
+      const coverage = lines.length > 0 ? Math.round(withNotesCount / lines.length * 100) : 0;
+      step2.push({
+        name: "agent_notes coverage",
+        passed: coverage >= 80,
+        message: `${coverage}% of products have agent_notes (${withNotesCount}/${lines.length})`,
+        detail: coverage < 80 ? "Aim for 100% coverage. Run: npx @opencommerceprotocol/cli generate to auto-generate notes" : void 0
+      });
+    }
+  } catch (err) {
+    step2.push({
+      name: "Product feed accessible",
+      passed: false,
+      message: `Network error: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  for (const r of step2) {
+    formatCheck(r);
+    allResults.push(r);
+  }
+  console.log();
+  console.log(import_chalk9.default.bold("Step 3: Evaluating agent_notes quality"));
+  const step3 = [];
+  if (firstProduct) {
+    const notesQuality = (0, import_validator2.scoreAgentNotes)(
+      firstProduct["agent_notes"],
+      firstProduct["name"]
+    );
+    step3.push({
+      name: "Sample product agent_notes",
+      passed: notesQuality.score >= 70,
+      message: `Score: ${notesQuality.score}/100 \u2014 "${firstProduct["name"]}"`,
+      detail: notesQuality.issues.length > 0 ? `Issues: ${notesQuality.issues.join("; ")}` : void 0
+    });
+    for (const r of step3) {
+      formatCheck(r);
+      allResults.push(r);
+    }
+    if (notesQuality.suggestions.length > 0 && options.verbose) {
+      console.log();
+      console.log(import_chalk9.default.bold("  agent_notes suggestions:"));
+      for (const s of notesQuality.suggestions) {
+        console.log(`  ${import_chalk9.default.yellow("\u2192")} ${s}`);
+      }
+    }
+    if (options.verbose && firstProduct["agent_notes"]) {
+      console.log();
+      console.log(import_chalk9.default.dim("  Sample agent_notes:"));
+      console.log(import_chalk9.default.dim(`  "${firstProduct["agent_notes"]}"`));
+    }
+  } else {
+    console.log(import_chalk9.default.dim("  (skipped \u2014 no products loaded)"));
+  }
+  console.log();
+  console.log(import_chalk9.default.bold("Step 4: Checking store description (ocp.md)"));
+  const step4 = [];
+  try {
+    const res = await fetch(`${baseUrl}/ocp.md`);
+    if (!res.ok) {
+      step4.push({
+        name: "ocp.md accessible",
+        passed: false,
+        message: "Not found \u2014 agents lack store context",
+        detail: "Add /ocp.md with a natural language description of your store"
+      });
+    } else {
+      const text = await res.text();
+      const hasHeadings = text.includes("#");
+      const isLong = text.length > 200;
+      step4.push({
+        name: "ocp.md accessible",
+        passed: true,
+        message: `Found (${text.length} chars)`
+      });
+      step4.push({
+        name: "ocp.md well-formatted",
+        passed: hasHeadings && isLong,
+        message: hasHeadings && isLong ? "Has headings and sufficient content" : "Minimal content \u2014 expand with store description, policies, and categories"
+      });
+    }
+  } catch {
+    step4.push({
+      name: "ocp.md accessible",
+      passed: false,
+      message: "Network error"
+    });
+  }
+  for (const r of step4) {
+    formatCheck(r);
+    allResults.push(r);
+  }
+  console.log();
+  console.log(import_chalk9.default.bold("Step 5: Checking discovery signals"));
+  const step5 = [];
+  try {
+    const res = await fetch(`${baseUrl}/robots.txt`);
+    if (res.ok) {
+      const text = await res.text();
+      const hasOcp = /OCP-Manifest:/i.test(text);
+      step5.push({
+        name: "robots.txt OCP-Manifest directive",
+        passed: hasOcp,
+        message: hasOcp ? "OCP-Manifest directive found" : "Missing \u2014 run: npx @opencommerceprotocol/cli robots"
+      });
+    } else {
+      step5.push({
+        name: "robots.txt OCP-Manifest directive",
+        passed: false,
+        message: "robots.txt not found"
+      });
+    }
+  } catch {
+    step5.push({
+      name: "robots.txt OCP-Manifest directive",
+      passed: false,
+      message: "Could not fetch robots.txt"
+    });
+  }
+  try {
+    const res = await fetch(`${baseUrl}/llms.txt`);
+    if (res.ok) {
+      const text = await res.text();
+      const hasCommerce = text.includes("## Commerce");
+      step5.push({
+        name: "llms.txt ## Commerce section",
+        passed: hasCommerce,
+        message: hasCommerce ? "## Commerce section found" : "Missing Commerce section \u2014 run: npx @opencommerceprotocol/cli llms"
+      });
+    } else {
+      step5.push({
+        name: "llms.txt ## Commerce section",
+        passed: false,
+        message: "llms.txt not found \u2014 run: npx @opencommerceprotocol/cli llms"
+      });
+    }
+  } catch {
+    step5.push({
+      name: "llms.txt ## Commerce section",
+      passed: false,
+      message: "Could not fetch llms.txt"
+    });
+  }
+  for (const r of step5) {
+    formatCheck(r);
+    allResults.push(r);
+  }
+  const totalChecks = allResults.length;
+  const passedChecks = allResults.filter((r) => r.passed).length;
+  const failedChecks = totalChecks - passedChecks;
+  const score = totalChecks > 0 ? Math.round(passedChecks / totalChecks * 100) : 0;
+  console.log();
+  console.log(import_chalk9.default.dim("\u2501".repeat(50)));
+  console.log();
+  const scoreColor2 = score === 100 ? import_chalk9.default.green : score >= 70 ? import_chalk9.default.yellow : import_chalk9.default.red;
+  console.log(
+    import_chalk9.default.bold("Result: ") + scoreColor2(`${passedChecks}/${totalChecks} checks passed`) + import_chalk9.default.dim(` (${score}/100)`)
+  );
+  if (failedChecks > 0) {
+    console.log();
+    console.log(import_chalk9.default.bold("Failed checks:"));
+    for (const r of allResults.filter((r2) => !r2.passed)) {
+      console.log(`  ${import_chalk9.default.red("\u2717")} ${r.name}: ${import_chalk9.default.yellow(r.message)}`);
+    }
+  }
+  console.log();
+  if (score === 100) {
+    console.log(import_chalk9.default.green("\u2713 All checks passed. This store is fully agent-ready."));
+  } else if (score >= 70) {
+    console.log(import_chalk9.default.yellow("\u26A0 Store is mostly agent-ready. Fix the failing checks above."));
+  } else {
+    console.log(import_chalk9.default.red("\u2717 Store needs significant work to be agent-ready. See checks above."));
+  }
+  console.log();
+  console.log(import_chalk9.default.dim("Next steps:"));
+  console.log(`  ${import_chalk9.default.cyan("npx @opencommerceprotocol/cli validate")} ${baseUrl}  \u2014 full validation report with score`);
+  console.log(`  ${import_chalk9.default.cyan("npx @opencommerceprotocol/cli stats")} --log /var/log/nginx/access.log  \u2014 see real agent traffic`);
+  console.log();
+}
+
+// src/commands/preview.ts
+var import_chalk10 = __toESM(require("chalk"));
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function renderAvailability(product) {
+  if (product["availability"]) {
+    const a = product["availability"];
+    const colors = {
+      in_stock: import_chalk10.default.green,
+      out_of_stock: import_chalk10.default.red,
+      limited: import_chalk10.default.yellow,
+      pre_order: import_chalk10.default.cyan,
+      backorder: import_chalk10.default.yellow,
+      check_site: import_chalk10.default.dim
+    };
+    return (colors[a] ?? import_chalk10.default.dim)(a.replace(/_/g, " "));
+  }
+  if (typeof product["in_stock"] === "boolean") {
+    return product["in_stock"] ? import_chalk10.default.green("in stock") : import_chalk10.default.red("out of stock");
+  }
+  return import_chalk10.default.dim("unknown");
+}
+async function runPreview(url, options) {
+  const baseUrl = url.replace(/\/$/, "");
+  const maxProducts = options.products ?? 5;
+  console.log("\n" + import_chalk10.default.bold("OCP Agent Preview"));
+  console.log(import_chalk10.default.dim("What an AI agent sees when it visits your store"));
+  console.log(import_chalk10.default.dim("\u2501".repeat(60)));
+  console.log();
+  let manifest = null;
+  try {
+    const res = await fetch(`${baseUrl}/.well-known/ocp.json`);
+    if (res.ok) {
+      manifest = await res.json();
+    }
+  } catch {
+  }
+  if (!manifest) {
+    console.log(import_chalk10.default.red("\u2717 No manifest found at /.well-known/ocp.json"));
+    console.log(import_chalk10.default.dim("  Run: npx @opencommerceprotocol/cli init"));
+    return;
+  }
+  const merchant = manifest["merchant"];
+  const capabilities = manifest["capabilities"];
+  const discovery = manifest["discovery"];
+  const bridge = manifest["bridge"];
+  console.log(import_chalk10.default.bold.cyan("\u2500\u2500 STORE IDENTITY \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(import_chalk10.default.bold("Name:    ") + (merchant?.["name"] ?? import_chalk10.default.dim("(not set)")));
+  console.log(import_chalk10.default.bold("URL:     ") + (merchant?.["url"] ?? import_chalk10.default.dim("(not set)")));
+  console.log(import_chalk10.default.bold("Currency:") + " " + (merchant?.["currency"] ?? import_chalk10.default.dim("(not set)")));
+  if (merchant?.["description"]) {
+    console.log(import_chalk10.default.bold("About:   ") + truncate(String(merchant["description"]), 120));
+  }
+  console.log();
+  console.log(import_chalk10.default.bold.cyan("\u2500\u2500 CAPABILITIES \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  const caps = [
+    ["catalog", "Browse product catalog"],
+    ["search", "Search products"],
+    ["cart", "Add to cart"],
+    ["checkout", "Initiate checkout"]
+  ];
+  for (const [key, label] of caps) {
+    const enabled = Boolean(capabilities?.[key]);
+    console.log(`  ${enabled ? import_chalk10.default.green("\u2713") : import_chalk10.default.dim("\u25CB")} ${label}`);
+  }
+  if (bridge && Object.values(bridge).some(Boolean)) {
+    console.log();
+    console.log(import_chalk10.default.bold.cyan("\u2500\u2500 PROTOCOL BRIDGES \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const protocols = ["mcp", "ucp", "acp", "a2a"];
+    for (const proto of protocols) {
+      if (bridge[proto]) {
+        console.log(`  ${import_chalk10.default.green("\u2713")} ${proto.toUpperCase()}: ${import_chalk10.default.dim(String(bridge[proto]))}`);
+      } else {
+        console.log(`  ${import_chalk10.default.dim("\u25CB")} ${proto.toUpperCase()} ${import_chalk10.default.dim("(not configured)")}`);
+      }
+    }
+  }
+  console.log();
+  console.log(import_chalk10.default.bold.cyan("\u2500\u2500 DISCOVERY SIGNALS \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  if (discovery) {
+    const feedUrl2 = discovery["feed"] ?? `${baseUrl}/ocp/products.jsonl`;
+    const feedUpdated = discovery["feed_updated"];
+    const totalProducts = discovery["total_products"];
+    console.log(`  ${import_chalk10.default.green("\u2713")} Feed: ${import_chalk10.default.dim(feedUrl2)}`);
+    if (totalProducts) {
+      console.log(`    ${import_chalk10.default.dim(`${totalProducts} products`)}`);
+    }
+    if (feedUpdated) {
+      const age = Math.round((Date.now() - new Date(feedUpdated).getTime()) / 1e3 / 3600);
+      const ageStr = age < 1 ? "just now" : age < 24 ? `${age}h ago` : `${Math.round(age / 24)}d ago`;
+      const ageColor = age < 48 ? import_chalk10.default.green : import_chalk10.default.yellow;
+      console.log(`    Last updated: ${ageColor(ageStr)}`);
+    } else {
+      console.log(`    ${import_chalk10.default.yellow("feed_updated not set \u2014 agents cannot assess freshness")}`);
+    }
+    if (discovery["feed_generated_from"]) {
+      console.log(`    Generated from: ${import_chalk10.default.dim(String(discovery["feed_generated_from"]))}`);
+    }
+  } else {
+    console.log(`  ${import_chalk10.default.yellow("No discovery section in manifest")}`);
+  }
+  console.log();
+  console.log(import_chalk10.default.bold.cyan("\u2500\u2500 STORE DESCRIPTION (ocp.md) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  try {
+    const res = await fetch(`${baseUrl}/ocp.md`);
+    if (res.ok) {
+      const text = await res.text();
+      const lines = text.split("\n").slice(0, options.verbose ? 30 : 15);
+      for (const line of lines) {
+        if (line.startsWith("# ")) {
+          console.log(import_chalk10.default.bold("  " + line));
+        } else if (line.startsWith("## ")) {
+          console.log(import_chalk10.default.cyan("  " + line));
+        } else {
+          console.log(import_chalk10.default.dim("  " + line));
+        }
+      }
+      if (!options.verbose && text.split("\n").length > 15) {
+        console.log(import_chalk10.default.dim(`  \u2026 (${text.split("\n").length - 15} more lines, use --verbose to see all)`));
+      }
+    } else {
+      console.log(import_chalk10.default.yellow("  Not found \u2014 agents lack store context"));
+      console.log(import_chalk10.default.dim("  Add /ocp.md with a natural language store description"));
+    }
+  } catch {
+    console.log(import_chalk10.default.dim("  Could not fetch ocp.md"));
+  }
+  console.log();
+  console.log(import_chalk10.default.bold.cyan(`\u2500\u2500 PRODUCT SAMPLE (first ${maxProducts}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+  const feedUrl = discovery?.["feed"] ?? `${baseUrl}/ocp/products.jsonl`;
+  try {
+    const res = await fetch(feedUrl);
+    if (!res.ok) {
+      console.log(import_chalk10.default.yellow(`  Feed not accessible at ${feedUrl}`));
+    } else {
+      const text = await res.text();
+      const lines = text.split("\n").filter((l) => l.trim());
+      const products = [];
+      for (const line of lines.slice(0, Math.min(lines.length, 500))) {
+        try {
+          products.push(JSON.parse(line));
+        } catch {
+        }
+      }
+      console.log(import_chalk10.default.dim(`  ${lines.length} total products in feed`));
+      console.log();
+      const sample = products.slice(0, maxProducts);
+      for (const p of sample) {
+        const price = `${p["currency"] ?? "USD"} ${Number(p["price"]).toFixed(2)}`;
+        const avail = renderAvailability(p);
+        console.log(`  ${import_chalk10.default.bold(String(p["name"]))} ${import_chalk10.default.dim(`(${p["id"]})`)} \u2014 ${price} \u2014 ${avail}`);
+        if (p["agent_notes"]) {
+          const notes = String(p["agent_notes"]);
+          const lengthColor = notes.length < 50 ? import_chalk10.default.red : notes.length < 100 ? import_chalk10.default.yellow : import_chalk10.default.green;
+          console.log(`  ${import_chalk10.default.dim("notes:")} ${lengthColor(truncate(notes, 120))}`);
+        } else {
+          console.log(`  ${import_chalk10.default.red("notes: (missing)")}`);
+        }
+        console.log();
+      }
+      console.log(import_chalk10.default.bold.cyan("\u2500\u2500 AGENT_NOTES QUALITY \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      const withNotes = products.filter((p) => p["agent_notes"]).length;
+      const coverage = Math.round(withNotes / products.length * 100);
+      const shortNotes = products.filter(
+        (p) => p["agent_notes"] && String(p["agent_notes"]).length < 50
+      ).length;
+      const missingNotes = products.length - withNotes;
+      const coverageColor = coverage >= 80 ? import_chalk10.default.green : coverage >= 50 ? import_chalk10.default.yellow : import_chalk10.default.red;
+      console.log(`  Coverage:     ${coverageColor(`${coverage}%`)} (${withNotes}/${products.length} products)`);
+      if (missingNotes > 0) {
+        console.log(`  ${import_chalk10.default.red("Missing:")}     ${missingNotes} products have no agent_notes`);
+      }
+      if (shortNotes > 0) {
+        console.log(`  ${import_chalk10.default.yellow("Too short:")}   ${shortNotes} products have notes under 50 chars`);
+      }
+      if (coverage === 100 && shortNotes === 0) {
+        console.log(`  ${import_chalk10.default.green("\u2713 All products have adequate agent_notes")}`);
+      }
+      const sorted = products.filter((p) => p["agent_notes"]).sort((a, b) => String(b["agent_notes"]).length - String(a["agent_notes"]).length);
+      if (sorted.length > 0 && options.verbose) {
+        console.log();
+        console.log(import_chalk10.default.bold("  Best agent_notes:"));
+        const best = sorted[0];
+        console.log(`  ${import_chalk10.default.dim(String(best["name"]))}`);
+        console.log(`  "${import_chalk10.default.green(truncate(String(best["agent_notes"]), 200))}"`);
+        if (sorted.length > 1) {
+          console.log();
+          console.log(import_chalk10.default.bold("  Worst agent_notes:"));
+          const worst = sorted[sorted.length - 1];
+          console.log(`  ${import_chalk10.default.dim(String(worst["name"]))}`);
+          console.log(`  "${import_chalk10.default.yellow(truncate(String(worst["agent_notes"]), 200))}"`);
+        }
+      }
+    }
+  } catch (err) {
+    console.log(import_chalk10.default.yellow(`  Could not load product feed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  console.log();
+  console.log(import_chalk10.default.dim("\u2501".repeat(60)));
+  console.log(import_chalk10.default.dim("Run `npx @opencommerceprotocol/cli validate " + baseUrl + "` for a full scored report."));
+  console.log(import_chalk10.default.dim("Run `npx @opencommerceprotocol/cli test-agent " + baseUrl + "` to simulate an agent visit."));
+  console.log();
+}
+
+// src/commands/agent-discover.ts
+var import_chalk11 = __toESM(require("chalk"));
+async function runAgentDiscover(url, options = {}) {
+  const { default: ora } = await import("ora");
+  const spinner = ora(`Discovering agents at ${import_chalk11.default.cyan(url)}`).start();
+  const base = url.replace(/\/$/, "");
+  let manifest = null;
+  let manifestUrl = null;
+  let mode = "none";
+  const candidates = [
+    `${base}/.well-known/agent.json`,
+    `${base}/.well-known/agent-tools`
+  ];
+  for (const candidateUrl of candidates) {
+    try {
+      const res = await fetchWithTimeout(candidateUrl, 8e3);
+      if (res.ok) {
+        const data = await res.json();
+        if (data && typeof data.name === "string" && Array.isArray(data.tools)) {
+          manifest = data;
+          manifestUrl = candidateUrl;
+          mode = "direct";
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  if (!manifest) {
+    try {
+      const ocpUrl = `${base}/.well-known/ocp.json`;
+      const res = await fetchWithTimeout(ocpUrl, 8e3);
+      if (res.ok) {
+        const ocp = await res.json();
+        if (ocp && typeof ocp["merchant"]?.["name"] === "string") {
+          manifest = convertOCPToAgentManifest(ocp, base);
+          manifestUrl = ocpUrl;
+          mode = "ocp_fallback";
+        }
+      }
+    } catch {
+    }
+  }
+  spinner.stop();
+  if (options.format === "json") {
+    if (manifest) {
+      console.log(JSON.stringify(manifest, null, 2));
+    } else {
+      console.log(JSON.stringify({ found: false, url: base }, null, 2));
+    }
+    return;
+  }
+  if (options.format === "mcp" && manifest) {
+    const mcpTools = toMCPTools(manifest);
+    console.log(JSON.stringify(mcpTools, null, 2));
+    return;
+  }
+  if (options.format === "openai" && manifest) {
+    const openaiTools = toOpenAITools(manifest);
+    console.log(JSON.stringify(openaiTools, null, 2));
+    return;
+  }
+  console.log("\n" + import_chalk11.default.bold("Agent Discovery Report"));
+  console.log(import_chalk11.default.dim("\u2501".repeat(52)));
+  console.log(import_chalk11.default.bold("URL:"), base);
+  console.log();
+  if (!manifest) {
+    check2(false, "Discovery endpoint not found");
+    console.log();
+    console.log(import_chalk11.default.yellow("  \u2192 Add /.well-known/agent.json to make your site agent-discoverable"));
+    console.log(import_chalk11.default.yellow("  \u2192 Or add /.well-known/ocp.json for OCP-compatible discovery"));
+    console.log();
+    return;
+  }
+  if (mode === "direct") {
+    check2(true, `Discovery endpoint found: ${import_chalk11.default.dim(manifestUrl ?? "")}`);
+  } else {
+    check2(true, `OCP fallback discovery: ${import_chalk11.default.dim(manifestUrl ?? "")}`);
+    console.log(import_chalk11.default.dim("  \u2139 To enable direct discovery, add /.well-known/agent.json"));
+  }
+  const tools = manifest.tools ?? [];
+  check2(tools.length > 0, `${tools.length} tool${tools.length === 1 ? "" : "s"} declared`);
+  let allToolsValid = true;
+  for (const tool of tools) {
+    if (!tool.name || !tool.endpoint) {
+      allToolsValid = false;
+      break;
+    }
+  }
+  check2(allToolsValid, allToolsValid ? "All tools have name and endpoint" : "Some tools missing required fields");
+  const toolsWithSchema = tools.filter((t) => t.parameters ?? t.schema);
+  const schemaValid = toolsWithSchema.length > 0;
+  check2(
+    schemaValid,
+    schemaValid ? `${toolsWithSchema.length}/${tools.length} tools have schema definitions` : "No tool schema definitions found (agents may not know what to send)"
+  );
+  const hasAuth = !!manifest.auth;
+  check2(hasAuth, hasAuth ? `Auth: ${manifest.auth?.type ?? "declared"}` : 'Auth not declared (add auth.type = "none" if public)');
+  const bridge = manifest.bridge;
+  if (bridge) {
+    console.log();
+    console.log(import_chalk11.default.bold("Protocol Bridges"));
+    check2(!!bridge["mcp"], bridge["mcp"] ? `MCP: ${bridge["mcp"]}` : "MCP bridge not configured");
+    check2(!!bridge["openai"], bridge["openai"] ? `OpenAI: ${bridge["openai"]}` : "OpenAI bridge not configured");
+    check2(!!bridge["a2a"], bridge["a2a"] ? `A2A: ${bridge["a2a"]}` : "A2A bridge not configured");
+  }
+  console.log();
+  console.log(import_chalk11.default.bold("Manifest Details"));
+  console.log(`  ${import_chalk11.default.dim("Name:")}         ${manifest.name ?? import_chalk11.default.dim("(not set)")}`);
+  if (manifest.description) {
+    console.log(`  ${import_chalk11.default.dim("Description:")}  ${manifest.description}`);
+  }
+  if (manifest.verticals?.length) {
+    console.log(`  ${import_chalk11.default.dim("Verticals:")}    ${manifest.verticals.join(", ")}`);
+  }
+  if (manifest.tool_format) {
+    console.log(`  ${import_chalk11.default.dim("Tool format:")}  ${manifest.tool_format}`);
+  }
+  if (manifest.updated_at) {
+    console.log(`  ${import_chalk11.default.dim("Updated:")}      ${manifest.updated_at}`);
+  }
+  if (options.verbose) {
+    console.log();
+    console.log(import_chalk11.default.bold("Tools"));
+    for (const tool of tools) {
+      console.log(`  ${import_chalk11.default.cyan(tool.name ?? "(unnamed)")}  ${import_chalk11.default.dim(tool.method ?? "POST")} ${tool.endpoint ?? ""}`);
+      if (tool.description) {
+        console.log(`    ${import_chalk11.default.dim(tool.description)}`);
+      }
+      if (tool.auth_required) {
+        console.log(`    ${import_chalk11.default.yellow("\u2691 requires auth")}`);
+      }
+      if (tool.rate_limit) {
+        console.log(`    ${import_chalk11.default.dim("rate limit:")} ${tool.rate_limit}`);
+      }
+    }
+  }
+  let score = 0;
+  if (manifest) score += 30;
+  if (mode === "direct") score += 20;
+  if (tools.length > 0) score += 20;
+  if (toolsWithSchema.length > 0) score += 15;
+  if (hasAuth) score += 10;
+  if (manifest.verticals?.length) score += 5;
+  console.log();
+  console.log(import_chalk11.default.dim("\u2501".repeat(52)));
+  console.log(
+    import_chalk11.default.bold("Agent Compatibility Score: ") + (score >= 80 ? import_chalk11.default.green : score >= 50 ? import_chalk11.default.yellow : import_chalk11.default.red)(String(score)) + import_chalk11.default.dim("/100")
+  );
+  if (score === 100) {
+    console.log(import_chalk11.default.green.bold("\n\u{1F389} Fully agent-compatible!\n"));
+  } else if (score >= 80) {
+    console.log(import_chalk11.default.green("\n\u2713 Good agent compatibility.\n"));
+  } else if (score >= 50) {
+    console.log(import_chalk11.default.yellow("\n\u26A0 Partial agent compatibility. Add missing fields to improve.\n"));
+  } else {
+    console.log(import_chalk11.default.red("\n\u2717 Low agent compatibility. Follow the recommendations above.\n"));
+  }
+}
+function check2(ok, msg) {
+  console.log((ok ? import_chalk11.default.green("  \u2713") : import_chalk11.default.yellow("  \u26A0")) + " " + msg);
+}
+async function fetchWithTimeout(url, ms) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+  try {
+    return await fetch(url, {
+      signal: controller.signal,
+      headers: { Accept: "application/json", "User-Agent": "OCPBot/1.0 (+https://opencommerceprotocol.org/bot)" }
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function convertOCPToAgentManifest(ocp, baseUrl) {
+  const merchant = ocp["merchant"];
+  const interact = ocp["interact"];
+  const bridge = ocp["bridge"];
+  const toolNames = Array.isArray(interact?.["tools"]) ? interact["tools"] : ["search_products", "get_product"];
+  const tools = toolNames.map((name) => ({
+    name,
+    endpoint: `/api/ocp/${name}`,
+    method: "POST",
+    description: `OCP tool: ${name}`
+  }));
+  const manifest = {
+    version: "1.0",
+    name: typeof merchant?.["name"] === "string" ? merchant["name"] : new URL(baseUrl).hostname,
+    tools,
+    verticals: ["commerce"],
+    tool_format: "jsonschema"
+  };
+  if (typeof merchant?.["description"] === "string") {
+    manifest.description = merchant["description"];
+  }
+  if (bridge) {
+    manifest.bridge = {};
+    if (typeof bridge["mcp"] === "string") manifest.bridge["mcp"] = bridge["mcp"];
+    if (typeof bridge["a2a"] === "string") manifest.bridge["a2a"] = bridge["a2a"];
+    if (typeof bridge["acp"] === "string") manifest.bridge["acp"] = bridge["acp"];
+  }
+  return manifest;
+}
+function toMCPTools(manifest) {
+  return (manifest.tools ?? []).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: buildInputSchema(tool)
+  }));
+}
+function toOpenAITools(manifest) {
+  return (manifest.tools ?? []).map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: buildInputSchema(tool)
+    }
+  }));
+}
+function buildInputSchema(tool) {
+  if (tool.parameters && typeof tool.parameters === "object") {
+    return tool.parameters;
+  }
+  if (tool.schema && typeof tool.schema === "object") {
+    return tool.schema;
+  }
+  return { type: "object", properties: {} };
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+program.name("ocp").description(import_chalk12.default.bold("Open Commerce Protocol") + " \u2014 Make any website shoppable by AI agents").version("1.0.0").addHelpText(
+  "after",
+  `
+${import_chalk12.default.bold("Examples:")}
+  ${import_chalk12.default.cyan("$ ocp init")}                               Interactive setup wizard
+  ${import_chalk12.default.cyan("$ ocp crawl https://mystore.com")}          Extract products from Schema.org JSON-LD
+  ${import_chalk12.default.cyan("$ ocp validate https://mystore.com")}       Validate a live OCP implementation
+  ${import_chalk12.default.cyan("$ ocp generate --products data.csv")}       Generate feed from product CSV
+  ${import_chalk12.default.cyan("$ ocp robots")}                             Add OCP-Manifest to robots.txt
+  ${import_chalk12.default.cyan("$ ocp llms")}                               Generate llms.txt Commerce section
+  ${import_chalk12.default.cyan("$ ocp bridge --protocol mcp")}              Generate MCP server bridge
+  ${import_chalk12.default.cyan("$ ocp stats --log /var/log/nginx/access.log")}  Analyze agent traffic in logs
+  ${import_chalk12.default.cyan("$ ocp test-agent https://mystore.com")}     Simulate an agent visiting your store
+  ${import_chalk12.default.cyan("$ ocp preview https://mystore.com")}        See what agents see in your store
+  ${import_chalk12.default.cyan("$ ocp agent-discover https://mystore.com")}  Discover agent tools at any URL
+
+${import_chalk12.default.dim("Documentation: https://opencommerceprotocol.org/docs")}
+`
+);
+program.command("init").description("Interactive wizard to generate OCP files for your store").option("-o, --output <dir>", "Output directory", ".").action(async (options) => {
+  await runInit(options.output);
+});
+program.command("validate").description("Validate an OCP implementation (URL or local directory)").argument("<target>", "URL (https://mystore.com) or local directory path").action(async (target) => {
+  await runValidate(target);
+});
+program.command("generate").description("Generate OCP files from existing product data (CSV, JSON, or JSONL)").option("-p, --products <file>", "Input product file (.csv, .json, or .jsonl)").option("-c, --config <file>", "OCP config file").option("-o, --output <dir>", "Output directory", ".").action(async (options) => {
+  await runGenerate(options);
+});
+program.command("bridge").description("Generate bridge configuration for other agent protocols").option("--protocol <protocol>", "Target protocol (mcp, ucp, a2a)", "mcp").option("-o, --output <dir>", "Output directory", "./bridge").option("-m, --manifest <file>", "OCP manifest file", ".well-known/ocp.json").action(async (options) => {
+  await runBridge(options);
+});
+program.command("crawl").description("Crawl a website, extract Schema.org Product JSON-LD, and generate OCP files").argument("<url>", "Base URL of the website to crawl").option("-o, --output <dir>", "Output directory", "./ocp-output").option("-c, --concurrency <n>", "Max concurrent requests", "5").option("--product-pattern <regex>", "URL pattern to identify product pages").option("--max-products <n>", "Maximum products to crawl").option("--delay <ms>", "Delay between requests in ms", "200").option("--user-agent <string>", "Custom User-Agent", "OCPBot/1.0 (+https://opencommerceprotocol.org/bot)").option("--include-variants", "Extract product variants", true).option("--generate-agent-notes", "Auto-generate agent_notes field", true).option("--dry-run", "List URLs that would be crawled without fetching", false).option("--verbose", "Print detailed extraction info per URL", false).option("--resume", "Resume a previously interrupted crawl", false).action(async (url, options) => {
+  const crawlOptions = {
+    output: options["output"],
+    concurrency: parseInt(options["concurrency"], 10) || 5,
+    delay: parseInt(options["delay"], 10) || 200,
+    userAgent: options["userAgent"],
+    includeVariants: options["includeVariants"] !== false,
+    generateAgentNotes: options["generateAgentNotes"] !== false,
+    dryRun: options["dryRun"] === true,
+    verbose: options["verbose"] === true,
+    resume: options["resume"] === true
+  };
+  if (options["productPattern"]) {
+    crawlOptions.productPattern = options["productPattern"];
+  }
+  if (options["maxProducts"]) {
+    crawlOptions.maxProducts = parseInt(options["maxProducts"], 10);
+  }
+  await runCrawl(url, crawlOptions);
+});
+program.command("robots").description("Add OCP-Manifest directive to robots.txt").argument("[path]", "Path to robots.txt file").option("--stdout", "Print modified content to stdout", false).option("--url <manifest-url>", "Custom manifest URL").action(async (filePath, options) => {
+  await runRobots(filePath, options);
+});
+program.command("llms").description("Generate or patch llms.txt with OCP Commerce section").argument("[path]", "Path to llms.txt file").option("--stdout", "Print content to stdout", false).option("--full", "Also generate llms-full.txt with product descriptions", false).action(async (filePath, options) => {
+  await runLlms(filePath, options);
+});
+program.command("stats").description("Analyze server access logs for OCP agent traffic patterns").argument("[url]", "Site URL (for contextual suggestions)").option("-l, --log <file>", "Path to server access log file").option("-f, --format <format>", "Log format: nginx, apache, cloudflare", "nginx").option("-d, --days <n>", "Number of days to analyze", "30").action(async (url, options) => {
+  const statsOpts = {
+    format: options.format ?? "nginx",
+    days: parseInt(options.days ?? "30", 10)
+  };
+  if (options.log) {
+    statsOpts.log = options.log;
+  }
+  await runStats(url, statsOpts);
+});
+program.command("test-agent").description("Simulate an AI agent visiting your store and output a pass/fail report").argument("<url>", "Base URL of the OCP-enabled store").option("-q, --query <query>", "Test search query", "product").option("-v, --verbose", "Show detailed output including sample agent_notes", false).action(async (url, options) => {
+  const testOpts = {
+    verbose: options.verbose ?? false
+  };
+  if (options.query) {
+    testOpts.query = options.query;
+  }
+  await runTestAgent(url, testOpts);
+});
+program.command("preview").description("Render what an AI agent sees when visiting your store").argument("<url>", "Base URL of the OCP-enabled store").option("-p, --products <n>", "Number of sample products to show", "5").option("-v, --verbose", "Show full ocp.md and best/worst agent_notes", false).action(async (url, options) => {
+  await runPreview(url, {
+    products: parseInt(options.products ?? "5", 10),
+    verbose: options.verbose ?? false
+  });
+});
+program.command("agent-discover").description("Discover agent tools at a URL via /.well-known/agent.json (Mode A) or OCP fallback").argument("<url>", "URL to discover agent tools at (e.g. https://mystore.com)").option("-v, --verbose", "Show full tool list with descriptions", false).option("--format <format>", "Output format: text, json, mcp, openai", "text").addHelpText(
+  "after",
+  `
+${import_chalk12.default.bold("Examples:")}
+  ${import_chalk12.default.cyan("$ ocp agent-discover https://example.com")}           Discover and validate agent tools
+  ${import_chalk12.default.cyan("$ ocp agent-discover https://example.com --verbose")}  Show full tool details
+  ${import_chalk12.default.cyan("$ ocp agent-discover https://example.com --format mcp")}   Export as MCP tool definitions
+  ${import_chalk12.default.cyan("$ ocp agent-discover https://example.com --format openai")} Export as OpenAI tool definitions
+  ${import_chalk12.default.cyan("$ ocp agent-discover https://example.com --format json")}   Raw manifest JSON
+`
+).action(async (url, options) => {
+  const discoverOptions = {
+    verbose: options.verbose ?? false
+  };
+  const fmt = options.format ?? "text";
+  if (fmt !== void 0) discoverOptions.format = fmt;
+  await runAgentDiscover(url, discoverOptions);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(import_chalk12.default.red("\nError:"), err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});