agent-ready-scanner 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,130 @@
+# agent-ready-cli
+
+Command-line client for [Agent Ready](https://agent-ready.dev) — scan any URL for **AI-agent readability** against the Vercel Agent Readability Spec, the [llmstxt.org](https://llmstxt.org) standard, and agent-protocol manifests (MCP server cards, A2A, `agents.json`, `agent-permissions.json`, UCP, x402, NLWeb).
+
+It's a thin wrapper over the hosted [agent-ready.dev REST API](https://agent-ready.dev/api/v1/openapi.json) — no scanning happens locally. For tool-native access from an AI assistant, see [`agent-ready-mcp`](https://github.com/mlava/agent-ready-mcp) instead.
+
+## Install
+
+```bash
+npm install -g agent-ready-scanner
+```
+
+This installs the `agent-ready` command. Or run without installing:
+
+```bash
+npx agent-ready-scanner scan https://example.com
+```
+
+> **Why `agent-ready-scanner`?** The bare `agent-ready` name is blocked by
+> npm's package-name similarity policy (it collides with an unrelated
+> `agentready` package). The installed command is still `agent-ready`.
+
+Requires Node.js ≥ 20.10.
+
+## Authentication
+
+`scan`, `get`, and `list` require a **Pro API key**. Issue one from the
+[dashboard](https://agent-ready.dev/dashboard/api-keys), then either:
+
+```bash
+export AGENT_READY_API_KEY="ar_live_..."
+# or pass per-command:
+agent-ready scan https://example.com --api-key ar_live_...
+```
+
+`ask` is public and needs no key.
+
+## Commands
+
+### `scan <url>`
+
+Starts a scan, polls until it finishes, and prints a readability summary.
+
+```bash
+agent-ready scan https://example.com
+agent-ready scan https://example.com --page-limit 25
+agent-ready scan https://example.com --no-wait      # queue only, print the id
+agent-ready scan https://example.com --json         # raw JSON
+```
+
+| Option | Description |
+| --- | --- |
+| `--page-limit <n>` | Max pages to crawl |
+| `--no-wait` | Queue the scan and print its id without polling |
+| `--poll-interval <s>` | Seconds between status polls (default 2) |
+| `--timeout <s>` | Max seconds to wait for completion (default 120) |
+
+### `get <id>`
+
+Fetch a scan by id (e.g. one started earlier with `--no-wait`).
+
+```bash
+agent-ready get V1StGXR8_Z
+agent-ready get V1StGXR8_Z --json
+```
+
+### `list`
+
+List your recent scans, newest first.
+
+```bash
+agent-ready list
+agent-ready list --limit 5
+agent-ready list --cursor 2026-05-30T00:00:00.000Z   # next page
+```
+
+### `ask <query...>`
+
+Natural-language search over Agent Ready's own docs (methodology, the check
+registry, supported specs). Public — no API key.
+
+```bash
+agent-ready ask "how is the score calculated?"
+agent-ready ask "what does check S4 do?" --type checks
+agent-ready ask "summarize the llms.txt requirements" --mode summarize
+```
+
+## Global options
+
+| Option | Description |
+| --- | --- |
+| `--json` | Output raw JSON instead of formatted text |
+| `--api-key <key>` | Override `AGENT_READY_API_KEY` |
+| `--base-url <url>` | Override `AGENT_READY_API_URL` (e.g. for local dev) |
+| `--no-color` | Disable coloured output ([`NO_COLOR`](https://no-color.org) is also honoured) |
+| `-h, --help` | Show help |
+| `-v, --version` | Show version |
+
+## Environment variables
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `AGENT_READY_API_KEY` | — | Pro API key for `scan`/`get`/`list` |
+| `AGENT_READY_API_URL` | `https://agent-ready.dev` | API base URL |
+| `AGENT_READY_SCAN_TIMEOUT_MS` | `120000` | Overall scan wait budget |
+| `AGENT_READY_GET_TIMEOUT_MS` | `10000` | Per-request timeout |
+
+## Exit codes
+
+| Code | Meaning |
+| --- | --- |
+| `0` | Success |
+| `1` | API error, scan failed, or scan timed out |
+| `2` | Usage error (bad arguments) |
+
+`--json` output goes to stdout; progress and errors go to stderr, so you can
+safely pipe JSON into other tools.
+
+## Development
+
+```bash
+npm install
+npm test          # vitest
+npm run typecheck # tsc --noEmit
+npm run build     # bundle to dist/cli.mjs
+```
+
+## License
+
+MIT © Agent Ready

package/dist/cli.mjs

@@ -0,0 +1,543 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://agent-ready.dev";
+var DEFAULT_SCAN_TIMEOUT_MS = 12e4;
+var DEFAULT_GET_TIMEOUT_MS = 1e4;
+function createConfig(env = process.env) {
+  const rawBase = env.AGENT_READY_API_URL ?? DEFAULT_BASE_URL;
+  const baseUrl = rawBase.replace(/\/+$/, "");
+  const apiKey = (env.AGENT_READY_API_KEY?.trim() ?? "") || null;
+  const scanTimeoutMs = positiveIntOr(
+    env.AGENT_READY_SCAN_TIMEOUT_MS,
+    DEFAULT_SCAN_TIMEOUT_MS
+  );
+  const getTimeoutMs = positiveIntOr(
+    env.AGENT_READY_GET_TIMEOUT_MS,
+    DEFAULT_GET_TIMEOUT_MS
+  );
+  return { baseUrl, apiKey, scanTimeoutMs, getTimeoutMs };
+}
+function positiveIntOr(raw, fallback) {
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+var ApiError = class extends Error {
+  constructor(code, message, status = null) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+async function call(config, opts) {
+  if (!config.apiKey) {
+    throw new ApiError(
+      "missing_api_key",
+      "No API key set. Issue a Pro API key from https://agent-ready.dev/dashboard/api-keys, then pass --api-key or set AGENT_READY_API_KEY."
+    );
+  }
+  const url = `${config.baseUrl}${opts.path}`;
+  const headers = {
+    Authorization: `Bearer ${config.apiKey}`,
+    Accept: "application/json"
+  };
+  if (opts.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  let res;
+  try {
+    res = await fetch(url, {
+      method: opts.method,
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0,
+      signal: AbortSignal.timeout(opts.timeoutMs)
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "TimeoutError") {
+      throw new ApiError(
+        "timeout",
+        `Request to ${opts.path} timed out after ${opts.timeoutMs}ms.`
+      );
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ApiError(
+      "network_error",
+      `Network error calling ${opts.path}: ${message}`
+    );
+  }
+  const text = await res.text();
+  let payload = null;
+  if (text.length > 0) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+    }
+  }
+  if (!res.ok) {
+    const detail = payload && typeof payload === "object" && "error" in payload ? payload.error : null;
+    const code = detail?.code ?? `http_${res.status}`;
+    const message = (detail?.message ?? text) || `HTTP ${res.status} from ${opts.path}`;
+    throw new ApiError(code, message, res.status);
+  }
+  return payload;
+}
+async function postScan(config, body) {
+  return call(config, {
+    method: "POST",
+    path: "/api/v1/scans",
+    body,
+    timeoutMs: config.getTimeoutMs
+  });
+}
+async function getScan(config, id) {
+  return call(config, {
+    method: "GET",
+    path: `/api/v1/scans/${encodeURIComponent(id)}`,
+    timeoutMs: config.getTimeoutMs
+  });
+}
+async function listScans(config, opts = {}) {
+  const params = new URLSearchParams();
+  if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+  if (opts.cursor) params.set("cursor", opts.cursor);
+  const query = params.toString();
+  return call(config, {
+    method: "GET",
+    path: `/api/v1/scans${query ? `?${query}` : ""}`,
+    timeoutMs: config.getTimeoutMs
+  });
+}
+async function postAsk(config, opts) {
+  const url = `${config.baseUrl}/api/v1/ask`;
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  if (config.apiKey) headers.Authorization = `Bearer ${config.apiKey}`;
+  const payloadBody = {
+    query: { q: opts.q, itemType: opts.itemType },
+    prefer: opts.mode ? { mode: opts.mode } : void 0
+  };
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payloadBody),
+      signal: AbortSignal.timeout(config.getTimeoutMs)
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "TimeoutError") {
+      throw new ApiError(
+        "timeout",
+        `Request to /api/v1/ask timed out after ${config.getTimeoutMs}ms.`
+      );
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ApiError(
+      "network_error",
+      `Network error calling /api/v1/ask: ${message}`
+    );
+  }
+  const text = await res.text();
+  let payload = null;
+  if (text.length > 0) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+    }
+  }
+  if (payload && typeof payload === "object" && "_meta" in payload) {
+    return payload;
+  }
+  if (!res.ok) {
+    throw new ApiError(`http_${res.status}`, text || `HTTP ${res.status}`, res.status);
+  }
+  return payload;
+}
+
+// src/format.ts
+var CODES = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function makePainter(enabled) {
+  if (!enabled) return (_code, text) => text;
+  return (code, text) => `${CODES[code]}${text}${CODES.reset}`;
+}
+var STATUS_ICON = {
+  pass: "\u2714",
+  fail: "\u2718",
+  warn: "\u25B2",
+  error: "\u2718"
+};
+var STATUS_COLOR = {
+  pass: "green",
+  fail: "red",
+  warn: "yellow",
+  error: "red"
+};
+function scoreColor(score) {
+  if (score >= 80) return "green";
+  if (score >= 50) return "yellow";
+  return "red";
+}
+function formatScan(scan, paint) {
+  const lines = [];
+  lines.push("");
+  lines.push(
+    `${paint("bold", scan.rootUrl)}  ${paint("gray", `(${scan.id})`)}`
+  );
+  lines.push("");
+  lines.push(
+    `  Vercel readability   ${paint(
+      scoreColor(scan.vercelScore),
+      `${scan.vercelScore}/100`
+    )}  ${paint("gray", scan.vercelRating.replace(/_/g, " "))}`
+  );
+  lines.push(
+    `  llms.txt             ${paint(
+      scoreColor(scan.llmstxtScore),
+      `${scan.llmstxtScore}/100`
+    )}`
+  );
+  lines.push(
+    paint(
+      "gray",
+      `  ${scan.pagesScanned}/${scan.pagesDiscovered} pages scanned`
+    )
+  );
+  const sections = [
+    ["Site checks", scan.siteChecks],
+    ["llms.txt checks", scan.llmstxtChecks]
+  ];
+  for (const [title, checks] of sections) {
+    const failed = checks.filter(
+      (c) => c.status === "fail" || c.status === "error" || c.status === "warn"
+    );
+    if (failed.length === 0) continue;
+    lines.push("");
+    lines.push(paint("bold", `  ${title} \u2014 ${failed.length} need attention`));
+    for (const c of failed) {
+      lines.push(formatCheckLine(c, paint));
+    }
+  }
+  const totalIssues = countNonPassing(scan.siteChecks) + countNonPassing(scan.llmstxtChecks);
+  lines.push("");
+  if (totalIssues === 0) {
+    lines.push(paint("green", "  All checks passed. \u{1F389}"));
+  } else {
+    lines.push(
+      paint("gray", `  ${totalIssues} check(s) need attention. `) + paint("cyan", `https://agent-ready.dev/scan/${scan.shareToken}`)
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatCheckLine(c, paint) {
+  const icon = paint(STATUS_COLOR[c.status], STATUS_ICON[c.status]);
+  const id = paint("gray", c.checkId.padEnd(4));
+  return `    ${icon} ${id} ${c.name}${c.message ? paint("dim", ` \u2014 ${c.message}`) : ""}`;
+}
+function countNonPassing(checks) {
+  return checks.filter((c) => c.status !== "pass").length;
+}
+function formatQueued(id, url, paint) {
+  return [
+    `${paint("green", "\u2714")} Scan queued for ${paint("bold", url)}`,
+    `  id:   ${id}`,
+    paint("gray", `  poll: agent-ready get ${id}`)
+  ].join("\n");
+}
+function formatScanList(rows, paint) {
+  if (rows.length === 0) {
+    return paint("gray", "No scans yet. Run `agent-ready scan <url>` to start one.");
+  }
+  const lines = rows.map((r) => {
+    const score = r.vercelScore === null ? paint("gray", " --") : paint(scoreColor(r.vercelScore), String(r.vercelScore).padStart(3));
+    const id = paint("gray", r.id.padEnd(12));
+    const when = paint("dim", formatDate(r.createdAt));
+    return `  ${score}  ${id} ${r.domain}  ${when}`;
+  });
+  return [paint("bold", "  score  id           domain  created"), ...lines].join(
+    "\n"
+  );
+}
+function formatDate(iso) {
+  return iso.replace("T", " ").replace(/:\d\d\.\d+Z$/, "Z").slice(0, 16);
+}
+function formatAsk(payload, paint) {
+  if (!payload || typeof payload !== "object") {
+    return JSON.stringify(payload, null, 2);
+  }
+  const obj = payload;
+  const meta = obj._meta ?? {};
+  const results = Array.isArray(obj.results) ? obj.results : [];
+  const metaMessage = typeof meta.message === "string" ? meta.message : void 0;
+  if (results.length === 0) {
+    return paint("yellow", metaMessage ?? "No results.");
+  }
+  const lines = [];
+  for (const r of results) {
+    if (!r || typeof r !== "object") continue;
+    const item = r;
+    const name = typeof item.name === "string" ? item.name : "(untitled)";
+    const url = typeof item.url === "string" ? item.url : "";
+    const desc = typeof item.description === "string" ? item.description : "";
+    lines.push(paint("bold", `\u2022 ${name}`));
+    if (url) lines.push(paint("cyan", `  ${url}`));
+    if (desc) lines.push(paint("dim", `  ${desc}`));
+  }
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var realApi = { postScan, getScan, listScans, postAsk };
+var HELP = `agent-ready \u2014 scan any URL for AI-agent readability (agent-ready.dev)
+
+USAGE
+  agent-ready <command> [options]
+
+COMMANDS
+  scan <url>        Start a scan and wait for the result
+  get <id>          Fetch a completed (or in-progress) scan by id
+  list              List your recent scans
+  ask <query...>    Natural-language search of Agent Ready's docs (no key needed)
+
+GLOBAL OPTIONS
+  --json            Output raw JSON instead of formatted text
+  --api-key <key>   API key (overrides AGENT_READY_API_KEY)
+  --base-url <url>  API base URL (overrides AGENT_READY_API_URL)
+  --no-color        Disable coloured output
+  -h, --help        Show this help
+  -v, --version     Show version
+
+SCAN OPTIONS
+  --page-limit <n>  Max pages to crawl
+  --no-wait         Queue the scan and print its id without polling
+  --poll-interval <s>  Seconds between status polls (default 2)
+  --timeout <s>     Max seconds to wait for completion (default 120)
+
+LIST OPTIONS
+  --limit <n>       Number of scans to return (1\u2013100, default 20)
+  --cursor <iso>    Pagination cursor (nextCursor from a prior response)
+
+ASK OPTIONS
+  --mode <list|summarize>   Result style
+  --type <itemType>         Restrict to: methodology | checks | specs | llms-txt | check
+
+AUTH
+  scan, get, and list need a Pro API key \u2014 get one at
+  https://agent-ready.dev/dashboard/api-keys. ask is public.
+
+EXAMPLES
+  agent-ready scan https://example.com
+  agent-ready scan https://example.com --json --page-limit 25
+  agent-ready get V1StGXR8_Z
+  agent-ready list --limit 5
+  agent-ready ask "how is the score calculated?"
+`;
+function parse(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      json: { type: "boolean" },
+      "api-key": { type: "string" },
+      "base-url": { type: "string" },
+      "no-color": { type: "boolean" },
+      "no-wait": { type: "boolean" },
+      "page-limit": { type: "string" },
+      "poll-interval": { type: "string" },
+      timeout: { type: "string" },
+      limit: { type: "string" },
+      cursor: { type: "string" },
+      mode: { type: "string" },
+      type: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  return { values, positionals };
+}
+function resolveConfig(env, values) {
+  const config = createConfig(env);
+  if (typeof values["api-key"] === "string") config.apiKey = values["api-key"];
+  if (typeof values["base-url"] === "string") {
+    config.baseUrl = values["base-url"].replace(/\/+$/, "");
+  }
+  if (typeof values.timeout === "string") {
+    const secs = Number(values.timeout);
+    if (Number.isFinite(secs) && secs > 0) config.scanTimeoutMs = secs * 1e3;
+  }
+  return config;
+}
+function intOption(raw, name) {
+  if (typeof raw !== "string") return void 0;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new ApiError("invalid_request", `--${name} must be a positive integer.`);
+  }
+  return n;
+}
+async function run(argv, env, io2, api = realApi) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (err) {
+    io2.err(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    io2.err("Run `agent-ready --help` for usage.");
+    return 2;
+  }
+  const { values, positionals } = parsed;
+  const command = positionals[0];
+  if (values.version) {
+    io2.out(VERSION);
+    return 0;
+  }
+  if (values.help || !command) {
+    io2.out(HELP);
+    return command ? 0 : values.help ? 0 : 1;
+  }
+  const color = io2.color && !values["no-color"];
+  const paint = makePainter(color);
+  const json = Boolean(values.json);
+  try {
+    switch (command) {
+      case "scan":
+        return await cmdScan(positionals.slice(1), values, env, io2, api, json, paint);
+      case "get":
+        return await cmdGet(positionals.slice(1), values, env, io2, api, json, paint);
+      case "list":
+        return await cmdList(values, env, io2, api, json, paint);
+      case "ask":
+        return await cmdAsk(positionals.slice(1), values, env, io2, api, json, paint);
+      default:
+        io2.err(`Unknown command: ${command}`);
+        io2.err("Run `agent-ready --help` for usage.");
+        return 2;
+    }
+  } catch (err) {
+    if (err instanceof ApiError) {
+      io2.err(`Error (${err.code}): ${err.message}`);
+      return 1;
+    }
+    io2.err(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function cmdScan(args, values, env, io2, api, json, paint) {
+  const url = args[0];
+  if (!url) {
+    io2.err("Usage: agent-ready scan <url> [--page-limit n] [--no-wait]");
+    return 2;
+  }
+  const config = resolveConfig(env, values);
+  const pageLimit = intOption(values["page-limit"], "page-limit");
+  const queued = await api.postScan(config, { url, pageLimit });
+  if (values["no-wait"]) {
+    if (json) io2.out(JSON.stringify(queued, null, 2));
+    else io2.out(formatQueued(queued.id, queued.url, paint));
+    return 0;
+  }
+  const pollSecs = intOption(values["poll-interval"], "poll-interval") ?? 2;
+  const deadline = Date.now() + config.scanTimeoutMs;
+  if (!json) io2.err(paint("gray", `Scanning ${url}\u2026`));
+  let scan = await api.getScan(config, queued.id);
+  while (scan.status === "running") {
+    if (Date.now() >= deadline) {
+      io2.err(
+        `Timed out waiting for scan ${queued.id} after ${Math.round(
+          config.scanTimeoutMs / 1e3
+        )}s. It may still finish \u2014 try \`agent-ready get ${queued.id}\`.`
+      );
+      return 1;
+    }
+    await io2.sleep(pollSecs * 1e3);
+    scan = await api.getScan(config, queued.id);
+  }
+  if (scan.status === "failed") {
+    io2.err(`Scan ${queued.id} failed.`);
+    if (json) io2.out(JSON.stringify(scan, null, 2));
+    return 1;
+  }
+  if (json) io2.out(JSON.stringify(scan, null, 2));
+  else io2.out(formatScan(scan, paint));
+  return 0;
+}
+async function cmdGet(args, values, env, io2, api, json, paint) {
+  const id = args[0];
+  if (!id) {
+    io2.err("Usage: agent-ready get <id>");
+    return 2;
+  }
+  const config = resolveConfig(env, values);
+  const scan = await api.getScan(config, id);
+  if (json) io2.out(JSON.stringify(scan, null, 2));
+  else if (scan.status === "running")
+    io2.out(paint("yellow", `Scan ${id} is still running. Try again shortly.`));
+  else io2.out(formatScan(scan, paint));
+  return 0;
+}
+async function cmdList(values, env, io2, api, json, paint) {
+  const config = resolveConfig(env, values);
+  const limit = intOption(values.limit, "limit");
+  const cursor = typeof values.cursor === "string" ? values.cursor : void 0;
+  const res = await api.listScans(config, { limit, cursor });
+  if (json) {
+    io2.out(JSON.stringify(res, null, 2));
+    return 0;
+  }
+  io2.out(formatScanList(res.data, paint));
+  if (res.nextCursor) {
+    io2.out(paint("gray", `
+More: agent-ready list --cursor ${res.nextCursor}`));
+  }
+  return 0;
+}
+async function cmdAsk(args, values, env, io2, api, json, paint) {
+  const q = args.join(" ").trim();
+  if (!q) {
+    io2.err('Usage: agent-ready ask "<question>"');
+    return 2;
+  }
+  const config = resolveConfig(env, values);
+  const mode = values.mode === "list" || values.mode === "summarize" ? values.mode : void 0;
+  const itemType = typeof values.type === "string" ? values.type : void 0;
+  const payload = await api.postAsk(config, { q, mode, itemType });
+  if (json) io2.out(JSON.stringify(payload, null, 2));
+  else io2.out(formatAsk(payload, paint));
+  return 0;
+}
+
+// src/bin.ts
+var io = {
+  out: (s) => process.stdout.write(s.endsWith("\n") ? s : `${s}
+`),
+  err: (s) => process.stderr.write(s.endsWith("\n") ? s : `${s}
+`),
+  // Colour when stdout is a TTY and NO_COLOR is unset (https://no-color.org).
+  color: process.stdout.isTTY === true && !process.env.NO_COLOR,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+run(process.argv.slice(2), process.env, io).then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  process.stderr.write(
+    `Fatal: ${err instanceof Error ? err.message : String(err)}
+`
+  );
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.mjs.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "agent-ready-scanner",
+  "version": "0.1.0",
+  "description": "Command-line client for Agent Ready — scan any URL for AI-readability against the Vercel Agent Readability Spec, the llmstxt.org standard, and agent-protocol manifests. Wraps the agent-ready.dev REST API.",
+  "license": "MIT",
+  "author": "Agent Ready",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mlava/agent-ready-cli.git"
+  },
+  "homepage": "https://agent-ready.dev",
+  "bugs": {
+    "url": "https://github.com/mlava/agent-ready-cli/issues"
+  },
+  "keywords": [
+    "cli",
+    "agent-readability",
+    "ai-search",
+    "llms-txt",
+    "agents-md",
+    "scanner",
+    "validator",
+    "vercel-spec",
+    "seo",
+    "nlweb"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20.10"
+  },
+  "bin": {
+    "agent-ready": "dist/cli.mjs"
+  },
+  "files": [
+    "dist/cli.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "dev": "node --experimental-strip-types src/bin.ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "@vitest/coverage-v8": "^2.1.9",
+    "esbuild": "^0.25.8",
+    "typescript": "^5.9.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^2.1.9"
+  }
+}