@anubhav-choubey/web-for-agents 0.1.0 → 0.2.0

package/dist/bin.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "./chunk-IF32TPGR.js";
-import "./chunk-CKXHTGGT.js";
-import "./chunk-LCVI2PRP.js";
+} from "./chunk-P6JSPAA2.js";
+import "./chunk-CGIIB6AF.js";
+import "./chunk-PHTV5NAY.js";
 import "./chunk-LCLDQ3A3.js";
 import "./chunk-FEAKVNMG.js";
-import "./chunk-AZG5MLNG.js";
+import "./chunk-F7PN5R25.js";
 import "./chunk-JJN6FNJD.js";
 
 // src/cli/bin.ts

package/dist/chunk-CGIIB6AF.js

@@ -0,0 +1,127 @@
+// src/shared/bots.ts
+var AI_BOTS = {
+  training: [
+    "GPTBot",
+    "ClaudeBot",
+    "CCBot",
+    "Google-Extended",
+    "Applebot-Extended",
+    "Meta-ExternalAgent",
+    "Bytespider",
+    "cohere-training-data-crawler"
+  ],
+  search: [
+    "OAI-SearchBot",
+    "ChatGPT-User",
+    "Claude-SearchBot",
+    "Claude-User",
+    "PerplexityBot",
+    "Perplexity-User"
+  ]
+};
+
+// src/shared/htmlScan.ts
+var isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
+var isAlpha = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122;
+function findRawEnd(html, name, from) {
+  let i = html.indexOf("</", from);
+  while (i !== -1) {
+    if (html.slice(i + 2, i + 2 + name.length).toLowerCase() === name) return i;
+    i = html.indexOf("</", i + 2);
+  }
+  return -1;
+}
+function* scanHtml(html, rawText) {
+  const n = html.length;
+  let i = 0;
+  while (i < n) {
+    const lt = html.indexOf("<", i);
+    if (lt === -1) return;
+    const c1 = lt + 1 < n ? html.charCodeAt(lt + 1) : 0;
+    if (c1 === 33 || c1 === 63) {
+      let end;
+      if (html.startsWith("<!--", lt)) {
+        const close = html.indexOf("-->", lt + 4);
+        end = close === -1 ? n : close + 3;
+      } else {
+        const close = html.indexOf(">", lt + 2);
+        end = close === -1 ? n : close + 1;
+      }
+      yield { type: "comment", start: lt, end };
+      i = end;
+      continue;
+    }
+    const closing = c1 === 47;
+    const nameStart = lt + (closing ? 2 : 1);
+    if (!isAlpha(nameStart < n ? html.charCodeAt(nameStart) : 0)) {
+      i = lt + 1;
+      continue;
+    }
+    let p = nameStart;
+    while (p < n) {
+      const c = html.charCodeAt(p);
+      if (isSpace(c) || c === 62 || c === 47) break;
+      p++;
+    }
+    const name = html.slice(nameStart, p).toLowerCase();
+    const attrs = [];
+    let selfClosing = false;
+    while (p < n) {
+      const c = html.charCodeAt(p);
+      if (isSpace(c)) {
+        p++;
+        continue;
+      }
+      if (c === 62) {
+        p++;
+        break;
+      }
+      if (c === 47) {
+        selfClosing = p + 1 < n && html.charCodeAt(p + 1) === 62;
+        p++;
+        continue;
+      }
+      const as = p;
+      while (p < n) {
+        const d = html.charCodeAt(p);
+        if (isSpace(d) || d === 62 || d === 47 || d === 61) break;
+        p++;
+      }
+      if (p === as) {
+        p++;
+        continue;
+      }
+      const attr = { name: html.slice(as, p).toLowerCase(), value: "", valueStart: -1, valueEnd: -1, quote: "" };
+      while (p < n && isSpace(html.charCodeAt(p))) p++;
+      if (p < n && html.charCodeAt(p) === 61) {
+        p++;
+        while (p < n && isSpace(html.charCodeAt(p))) p++;
+        const q = p < n ? html[p] : "";
+        if (q === '"' || q === "'") {
+          const close = html.indexOf(q, p + 1);
+          const stop = close === -1 ? n : close;
+          Object.assign(attr, { value: html.slice(p + 1, stop), valueStart: p + 1, valueEnd: stop, quote: q });
+          p = close === -1 ? n : close + 1;
+        } else {
+          const vs = p;
+          while (p < n && !isSpace(html.charCodeAt(p)) && html.charCodeAt(p) !== 62) p++;
+          Object.assign(attr, { value: html.slice(vs, p), valueStart: vs, valueEnd: p });
+        }
+      }
+      attrs.push(attr);
+    }
+    yield { type: "tag", closing, name, attrs, selfClosing, start: lt, end: p };
+    i = p;
+    if (!closing && !selfClosing && rawText.has(name)) {
+      const end = findRawEnd(html, name, i);
+      const stop = end === -1 ? n : end;
+      yield { type: "raw", name, start: i, end: stop };
+      i = stop;
+    }
+  }
+}
+
+export {
+  AI_BOTS,
+  scanHtml
+};

package/dist/{chunk-AZG5MLNG.js → chunk-F7PN5R25.js}

@@ -47,6 +47,7 @@ var PRERENDERED_ATTR = "data-wfa-prerendered";
 var READY_GLOBAL = "__WFA_READY__";
 var HIDDEN_SELECTOR = '[hidden], [aria-hidden="true"]';
 var HEAD_OWNED_ATTR = "data-wfa";
+var MARKDOWN_LINK_KEY = "markdown";
 function markdownPathFor(pathname) {
   const p = normalizeRoute(pathname);
   return p === "/" ? "/index.md" : p + ".md";
@@ -81,6 +82,7 @@ export {
   READY_GLOBAL,
   HIDDEN_SELECTOR,
   HEAD_OWNED_ATTR,
+  MARKDOWN_LINK_KEY,
   markdownPathFor,
   ACTION_ATTR,
   ACTION_DESCRIPTION_ATTR,

package/dist/chunk-LCVPXUFN.js

@@ -0,0 +1,245 @@
+import {
+  collapseWhitespace
+} from "./chunk-FEAKVNMG.js";
+import {
+  ACTION_PARAM_ATTR,
+  HIDDEN_SELECTOR,
+  WEBMCP_TOOLPARAMDESCRIPTION_ATTR
+} from "./chunk-F7PN5R25.js";
+
+// src/shared/object.ts
+var hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+
+// src/runtime/agent/dom.ts
+var INERT_OR_CLOSED = "[inert], dialog:not([open]), details:not([open]) > :not(summary)";
+var CONCEALED = `${HIDDEN_SELECTOR}, ${INERT_OR_CLOSED}`;
+function inDisabledFieldset(el) {
+  for (let child = el, p = el.parentElement; p; child = p, p = p.parentElement) {
+    if (p.matches("fieldset[disabled]") && child !== p.querySelector(":scope > legend")) return true;
+  }
+  return false;
+}
+function isDisabled(el) {
+  return el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true" || inDisabledFieldset(el);
+}
+function isConcealed(el) {
+  if (!el.closest(CONCEALED)) return false;
+  const labels = el.tagName === "INPUT" && /^(checkbox|radio)$/.test(el.type) ? el.labels : null;
+  return !(labels && el.getAttribute("aria-hidden") !== "true" && !el.matches(INERT_OR_CLOSED) && !el.parentElement?.closest(CONCEALED) && Array.from(labels).some((l) => !isConcealed(l) && !isDisabled(l)));
+}
+
+// src/runtime/agent/formSchema.ts
+var EMPTY_OBJECT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: Object.freeze({}),
+  additionalProperties: false
+});
+var EXCLUDED_TYPES = /* @__PURE__ */ new Set(["hidden", "password", "file", "submit", "button", "reset", "image"]);
+function isAgentField(e) {
+  const tag = e.tagName;
+  if (tag !== "INPUT" && tag !== "SELECT" && tag !== "TEXTAREA") return false;
+  if (!e.getAttribute("name")) return false;
+  if (e.hasAttribute("disabled") || e.hasAttribute("readonly") || inDisabledFieldset(e)) return false;
+  if (tag === "INPUT" && EXCLUDED_TYPES.has((e.getAttribute("type") ?? "text").toLowerCase())) return false;
+  return !isConcealed(e);
+}
+function agentFields(form) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const el of Array.from(form.elements)) {
+    if (!isAgentField(el)) continue;
+    const name = el.getAttribute("name");
+    const list = groups.get(name);
+    if (list) list.push(el);
+    else groups.set(name, [el]);
+  }
+  return groups;
+}
+function labelText(el) {
+  const labels = el.labels ? Array.from(el.labels) : [];
+  if (labels.length === 0) {
+    const wrap = el.closest("label");
+    if (wrap) labels.push(wrap);
+  }
+  return collapseWhitespace(
+    labels.map((l) => {
+      const c = l.cloneNode(true);
+      c.querySelectorAll("input,select,textarea,button").forEach((n) => n.remove());
+      return c.textContent;
+    }).join(" ")
+  );
+}
+function describe(el) {
+  return collapseWhitespace(el.getAttribute(ACTION_PARAM_ATTR)) || collapseWhitespace(el.getAttribute(WEBMCP_TOOLPARAMDESCRIPTION_ATTR)) || labelText(el) || collapseWhitespace(el.getAttribute("aria-label")) || collapseWhitespace(el.getAttribute("placeholder"));
+}
+function num(el, attr) {
+  const v = el.getAttribute(attr);
+  if (v === null || v.trim() === "") return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function inputSchema(el) {
+  const type = el.tagName === "TEXTAREA" ? "textarea" : (el.getAttribute("type") ?? "text").toLowerCase();
+  const s = {};
+  if (type === "checkbox") {
+    s.type = "boolean";
+    return s;
+  }
+  if (type === "number" || type === "range") {
+    const step = el.getAttribute("step");
+    s.type = step === null || /^\d+$/.test(step.trim()) ? "integer" : "number";
+    const min = num(el, "min");
+    const max = num(el, "max");
+    if (min !== void 0) s.minimum = min;
+    if (max !== void 0) s.maximum = max;
+    return s;
+  }
+  s.type = "string";
+  if (type === "email") s.format = "email";
+  else if (type === "url") s.format = "uri";
+  else if (type === "date") s.format = "date";
+  else if (type === "time") s.format = "time";
+  const minLength = num(el, "minlength");
+  const maxLength = num(el, "maxlength");
+  if (minLength !== void 0) s.minLength = minLength;
+  if (maxLength !== void 0) s.maxLength = maxLength;
+  const pattern = el.getAttribute("pattern");
+  if (pattern) s.pattern = `^(?:${pattern})$`;
+  return s;
+}
+function withDescription(s, desc) {
+  if (desc) s.description = desc;
+  return s;
+}
+function selectSchema(sel, desc) {
+  const opts = Array.from(sel.querySelectorAll("option")).filter((o) => !o.hasAttribute("disabled") && !o.hasAttribute("hidden") && !o.closest("optgroup[disabled]")).map((o) => ({ value: o.getAttribute("value") ?? collapseWhitespace(o.textContent), label: collapseWhitespace(o.textContent) })).filter((o) => o.value !== "");
+  const values = opts.map((o) => o.value);
+  const list = opts.map((o) => o.label && o.label !== o.value ? `${o.value} (${o.label})` : o.value).join(", ");
+  const schema = sel.hasAttribute("multiple") ? { type: "array", items: { type: "string", enum: values } } : { type: "string", enum: values };
+  return withDescription(schema, [desc, `Options: ${list}`].filter(Boolean).join(". "));
+}
+var isType = (e, t) => e.tagName === "INPUT" && (e.getAttribute("type") ?? "").toLowerCase() === t;
+function groupSchema(els) {
+  const first = els[0];
+  const desc = els.map(describe).find(Boolean) ?? "";
+  if (first.tagName === "SELECT") return selectSchema(first, desc);
+  const values = () => els.map((e) => e.getAttribute("value") ?? "on");
+  if (els.every((e) => isType(e, "radio"))) return withDescription({ type: "string", enum: values() }, desc);
+  if (els.length > 1 && els.every((e) => isType(e, "checkbox"))) {
+    return withDescription({ type: "array", items: { type: "string", enum: values() } }, desc);
+  }
+  return withDescription(inputSchema(first), desc);
+}
+function schemaFromForm(form) {
+  const properties = /* @__PURE__ */ Object.create(null);
+  const required = [];
+  for (const [name, els] of agentFields(form)) {
+    properties[name] = groupSchema(els);
+    if (els.some((e) => e.hasAttribute("required"))) required.push(name);
+  }
+  const out = { type: "object", properties, additionalProperties: false };
+  if (required.length) out.required = required;
+  return out;
+}
+var MAX_REGEX_INPUT = 1e4;
+function checkValue(s, v, field, errors) {
+  const bad = (message) => {
+    errors.push({ field, message });
+  };
+  switch (s.type) {
+    case "string":
+      if (typeof v !== "string") return bad("must be string");
+      break;
+    case "number":
+      if (typeof v !== "number" || !Number.isFinite(v)) return bad("must be number");
+      break;
+    case "integer":
+      if (typeof v !== "number" || !Number.isInteger(v)) return bad("must be integer");
+      break;
+    case "boolean":
+      if (typeof v !== "boolean") return bad("must be boolean");
+      break;
+    case "array":
+      if (!Array.isArray(v)) return bad("must be array");
+      break;
+    case "object":
+      if (!isPlainObject(v)) return bad("must be object");
+      checkObject(s, v, `${field}.`, errors);
+      return;
+  }
+  if (s.enum && !s.enum.includes(v)) {
+    return bad(`must be one of: ${s.enum.join(", ")}`);
+  }
+  if (typeof v === "string") {
+    if (s.minLength !== void 0 && v.length < s.minLength) bad(`must be at least ${s.minLength} characters`);
+    if (s.maxLength !== void 0 && v.length > s.maxLength) bad(`must be at most ${s.maxLength} characters`);
+    if ((s.pattern !== void 0 || s.format === "email") && v.length > MAX_REGEX_INPUT) {
+      return bad(`must be at most ${MAX_REGEX_INPUT} characters to be checked`);
+    }
+    if (s.pattern !== void 0) {
+      let ok = false;
+      try {
+        ok = new RegExp(s.pattern).test(v);
+      } catch {
+        ok = false;
+      }
+      if (!ok) bad(`must match pattern ${s.pattern}`);
+    }
+    if (s.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v)) bad("must be a valid email");
+    if (s.format === "uri") {
+      try {
+        new URL(v);
+      } catch {
+        bad("must be a valid URI");
+      }
+    }
+  }
+  if (typeof v === "number") {
+    if (s.minimum !== void 0 && v < s.minimum) bad(`must be >= ${s.minimum}`);
+    if (s.maximum !== void 0 && v > s.maximum) bad(`must be <= ${s.maximum}`);
+  }
+  if (Array.isArray(v) && s.items) {
+    v.forEach((item, i) => checkValue(s.items, item, `${field}[${i}]`, errors));
+  }
+}
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function checkObject(schema, obj, prefix, errors) {
+  const props = schema.properties ?? {};
+  for (const name of schema.required ?? []) {
+    if (!hasOwn(obj, name) || obj[name] === void 0) errors.push({ field: prefix + name, message: "is required" });
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const prop = props[key];
+    if (!hasOwn(props, key) || !prop) {
+      if (schema.additionalProperties !== true) errors.push({ field: prefix + key, message: "is not an allowed field" });
+      continue;
+    }
+    if (value === void 0) continue;
+    checkValue(prop, value, prefix + key, errors);
+  }
+}
+function validateInput(schema, input) {
+  if (!isPlainObject(input)) return { ok: false, errors: [{ field: "", message: "input must be an object" }] };
+  const errors = [];
+  checkObject(schema, input, "", errors);
+  return errors.length ? { ok: false, errors } : { ok: true, value: input };
+}
+function validateFormInput(schema, input) {
+  const r = validateInput({ ...schema, additionalProperties: true }, input);
+  return r.ok ? r : validateInput(schema, input);
+}
+
+export {
+  hasOwn,
+  inDisabledFieldset,
+  isDisabled,
+  isConcealed,
+  EMPTY_OBJECT_SCHEMA,
+  agentFields,
+  schemaFromForm,
+  validateInput,
+  validateFormInput
+};