@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-ZXYDDJEJ.js

@@ -0,0 +1,1252 @@
+import {
+  createLLMClient
+} from "./chunk-SQZHPD3S.js";
+import {
+  logger
+} from "./chunk-X4HAERTQ.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/arena/index.ts
+init_esm_shims();
+
+// src/arena/iterate/index.ts
+init_esm_shims();
+
+// src/arena/iterate/iterative-arena.ts
+init_esm_shims();
+
+// src/arena/iterate/convergence.ts
+init_esm_shims();
+function diffRatio(a, b) {
+  if (a === b) return 0;
+  if (!a || !b) return 1;
+  const trigrams = (s) => {
+    const out = /* @__PURE__ */ new Set();
+    for (let i = 0; i < s.length - 2; i++) out.add(s.slice(i, i + 3));
+    return out;
+  };
+  const A = trigrams(a);
+  const B = trigrams(b);
+  let inter = 0;
+  for (const t of A) if (B.has(t)) inter++;
+  const union = A.size + B.size - inter;
+  if (union === 0) return 0;
+  const jaccard = inter / union;
+  return 1 - jaccard;
+}
+function defaultConvergence(args) {
+  const { round, critiques, draft, previousDraft } = args;
+  const blockerCount = critiques.filter((c) => c.severity === "blocker").length;
+  const majorCount = critiques.filter((c) => c.severity === "major").length;
+  const totalCritiques = critiques.length;
+  const diffFromPrevious = previousDraft ? diffRatio(previousDraft.content, draft.content) : 1;
+  if (round === 1) {
+    return {
+      blockerCount,
+      majorCount,
+      totalCritiques,
+      diffFromPrevious,
+      shouldStop: false,
+      reason: "running"
+    };
+  }
+  if (totalCritiques === 0) {
+    return {
+      blockerCount,
+      majorCount,
+      totalCritiques,
+      diffFromPrevious,
+      shouldStop: false,
+      reason: "running"
+    };
+  }
+  if (blockerCount === 0 && majorCount === 0 && totalCritiques >= 3) {
+    return {
+      blockerCount,
+      majorCount,
+      totalCritiques,
+      diffFromPrevious,
+      shouldStop: true,
+      reason: "all_minor_or_praise"
+    };
+  }
+  if (blockerCount === 0 && diffFromPrevious < 0.05) {
+    return {
+      blockerCount,
+      majorCount,
+      totalCritiques,
+      diffFromPrevious,
+      shouldStop: true,
+      reason: "blockers_zero_and_stable"
+    };
+  }
+  return {
+    blockerCount,
+    majorCount,
+    totalCritiques,
+    diffFromPrevious,
+    shouldStop: false,
+    reason: "running"
+  };
+}
+
+// src/arena/iterate/formats/index.ts
+init_esm_shims();
+var COMMON_DRAFT_RULES = `
+Hard rules:
+- Output the FULL artifact, not a sketch or outline.
+- No "...", "(continued)", "see above", "TBD", or placeholders.
+- Don't pad with filler. Every section must carry information.
+- Length is a floor, not a target \u2014 go beyond it if the topic warrants.
+
+Factual discipline (CRITICAL \u2014 fabrication = blocker-level defect):
+- Do NOT invent specific numbers, percentages, dollar amounts, market sizes,
+  user-research counts, or "industry averages" you cannot verify.
+- Do NOT invent URLs, report IDs, document numbers, citation references.
+- Do NOT invent named people, companies, or product code-names.
+- For unknowable specifics, write a placeholder with the exact form:
+    [\u9700\u8C03\u7814: \u5177\u4F53\u8BF4\u660E]    e.g.  "[\u9700\u8C03\u7814: \u5B9E\u9645\u884C\u4E1A\u6D41\u5931\u7387\u57FA\u51C6]"
+    [TBD: short reason]   e.g.  "[TBD: confirm Stripe rate limits]"
+  These placeholders are EXPECTED. Reviewers will not fault you for them.
+- General qualitative claims are fine ("annual growth typically in the
+  double digits"); specific numbers without a verifiable source are NOT.
+- If you have web-search tools available, USE them before stating any
+  specific number or citing any source.
+`;
+function formatCritiquesForPrompt(critiques) {
+  return critiques.map(
+    (c, i) => `[${i + 1}] id=${c.id} severity=${c.severity} category=${c.category} from=${c.critic}
+    anchor: "${c.anchor}"
+    comment: ${c.comment}` + (c.suggestion ? `
+    suggestion: ${c.suggestion}` : "")
+  ).join("\n\n");
+}
+var codeFormat = {
+  format: "code",
+  draftPrompt(subject, minLength) {
+    return `You are writing a complete code artifact for the following task.
+
+Task: ${subject.label}
+Description: ${subject.description}
+${subject.sources?.length ? `Source files for context: ${subject.sources.join(", ")}` : ""}
+
+This draft will compete with drafts from other participants in a tournament round.
+A merger will then read all drafts (anonymously) and pick the strongest parts.
+Make your draft strong, distinct, complete, and self-contained.
+
+Output requirements:
+- Compile-ready code in the appropriate language (infer from sources / description).
+- Include tests if behavior is non-trivial.
+- Inline comments only where the WHY is non-obvious \u2014 names should explain WHAT.
+- At least ${minLength} characters of substantive code (filler will be cut by the merger).
+${COMMON_DRAFT_RULES}`;
+  },
+  mergePrompt(subject, candidates, minLength) {
+    const blocks = candidates.map((c) => `--- ${c.anonymousLabel} ---
+${c.content}
+--- end ${c.anonymousLabel} ---`).join("\n\n");
+    return `Below are ${candidates.length} draft solutions for the same task, presented anonymously.
+Your job: produce a single v1 by merging the strongest parts of each.
+
+Task: ${subject.label}
+Description: ${subject.description}
+
+${blocks}
+
+Merging rules:
+- For each section / function / module, pick the strongest version OR write a new one inspired by the best ideas.
+- Inline EVERYTHING. Do not write "see Draft B for the auth helper" \u2014 copy the auth helper in.
+- v1 must be COMPLETE and at least ${minLength} characters of substantive code.
+- After the code, output a 'mergeRationale' section: one short paragraph per major decision, "From Draft X I took ____, because ____. I rejected ____ because ____."
+
+Output format (literally \u2014 these markers will be parsed):
+
+<v1_content>
+{full code goes here}
+</v1_content>
+
+<merge_rationale>
+{your rationale here}
+</merge_rationale>`;
+  },
+  argueSystem() {
+    return `You are reviewing a code artifact. Find every meaningful issue.
+
+You may have access to a web_search tool \u2014 USE IT to verify any specific
+claim, library version, API behavior, or external reference made in the
+draft before deciding whether it's a fabrication.
+
+For each issue:
+- "anchor": quote 5-15 words verbatim from the draft to locate the issue.
+- "severity": "blocker" (must fix), "major" (should fix), "minor" (nice to fix), "nit" (style), or "praise" (good \u2014 don't gut this).
+- "category": "correctness" | "completeness" | "clarity" | "evidence" | "structure" | "style" | "fabrication" | "other".
+- "comment": what's wrong and what you'd do. If you used web_search, cite the URL.
+- "suggestion": optional concrete fix.
+- "evidence": optional array of {url, snippet} pairs supporting your critique.
+
+FABRICATION DETECTION (top priority):
+Any specific number, citation, URL, version string, API endpoint, library
+function, or named entity that you cannot verify is a "fabrication"
+critique with severity = "blocker". Be especially suspicious of:
+- "Industry average is X%" / "Surveys show N=..."
+- Documentation URLs with suspiciously generic paths
+- Library/API names that "sound right" but you can't confirm exist
+
+Aim for 8-20 critiques. Include PRAISE for parts that are genuinely good \u2014 this prevents the author from accidentally gutting them in the next revision.
+
+Output strictly as JSON: {"critiques": [{...}, ...]}`;
+  },
+  argueUser(subject, draft, lens) {
+    return `Task: ${subject.label}
+${lens ? `Review lens: ${lens}
+` : ""}
+Current draft (v${draft.version}, by ${draft.author}):
+
+${draft.content}
+
+Now produce your critiques as JSON.`;
+  },
+  revisePrompt(subject, previous, critiques, minLength) {
+    return `You wrote v${previous.version}. Critics raised ${critiques.length} points.
+Rewrite the artifact as v${previous.version + 1}.
+
+Task: ${subject.label}
+Description: ${subject.description}
+
+Current draft (v${previous.version}):
+${previous.content}
+
+Critiques:
+${formatCritiquesForPrompt(critiques)}
+
+Rules:
+- ADDRESS every blocker and major. You may disagree, but say why in changelog.
+- Preserve PRAISE-tagged parts unless a later critique contradicts.
+- Output the COMPLETE new artifact (at least ${minLength} chars), not a diff.
+- After the code, output a JSON block:
+
+<v_next_content>
+{full code goes here}
+</v_next_content>
+
+<v_next_meta>
+{
+  "acceptedCritiques": ["id1", "id2", ...],
+  "rejectedCritiques": [{"id": "id3", "reason": "..."}, ...],
+  "changelog": "what changed and why, in 1-3 short paragraphs"
+}
+</v_next_meta>`;
+  }
+};
+var documentFormat = {
+  format: "document",
+  draftPrompt(subject, minLength) {
+    return `You are writing a complete long-form document for the following subject.
+
+Subject: ${subject.label}
+Description: ${subject.description}
+${subject.sources?.length ? `Reference materials: ${subject.sources.join(", ")}` : ""}
+
+This draft will compete with drafts from other participants in a tournament round.
+A merger will then read all drafts (anonymously) and pick the strongest parts.
+Make your draft strong, distinct, complete, and self-contained.
+
+Document requirements:
+- Use clear hierarchical structure (## sections, ### subsections).
+- Every section must carry concrete information: examples, comparisons, trade-offs, numbers.
+- Cite sources inline with [n] footnotes when you make factual claims.
+- At least ${minLength} characters of substantive prose (filler will be cut by the merger).
+${COMMON_DRAFT_RULES}`;
+  },
+  mergePrompt(subject, candidates, minLength) {
+    const blocks = candidates.map((c) => `--- ${c.anonymousLabel} ---
+${c.content}
+--- end ${c.anonymousLabel} ---`).join("\n\n");
+    return `Below are ${candidates.length} draft documents for the same subject, presented anonymously.
+Your job: produce a single v1 markdown document by merging the strongest parts.
+
+Subject: ${subject.label}
+Description: ${subject.description}
+
+${blocks}
+
+Merging rules:
+- Pick the strongest section from each draft, OR write a new section that combines their best ideas.
+- DO NOT write "see Draft B for ____" \u2014 inline everything.
+- The final v1 must be COMPLETE and at least ${minLength} characters.
+- Maintain coherent voice and consistent structure across sections.
+
+Output format (literally \u2014 these markers will be parsed):
+
+<v1_content>
+{full markdown document}
+</v1_content>
+
+<merge_rationale>
+{1-3 short paragraphs: from which draft you took which section, why; what you rejected, why}
+</merge_rationale>`;
+  },
+  argueSystem() {
+    return `You are reviewing a long-form document. Find every meaningful issue.
+
+You may have access to a web_search tool \u2014 USE IT to verify any specific
+number, citation, market figure, named survey, or external reference
+before deciding whether it's a fabrication.
+
+For each issue:
+- "anchor": quote 5-15 words verbatim from the document to locate the issue.
+- "severity": "blocker" | "major" | "minor" | "nit" | "praise".
+- "category": "correctness" | "completeness" | "clarity" | "evidence" | "structure" | "style" | "fabrication" | "other".
+- "comment": what's wrong / missing / weak. If you used web_search, cite the URL.
+- "suggestion": optional concrete fix or content to add.
+- "evidence": optional array of {url, snippet} pairs supporting your critique.
+
+FABRICATION DETECTION (top priority):
+The document is far more likely to fail because of fabricated facts than
+because of missing sections. Treat every specific number / report ID /
+URL / dollar figure / "industry average" / named survey as suspect until
+verified. Mark as severity = "blocker" if:
+- The number cannot be found via web_search.
+- The cited URL doesn't resolve to the claimed source.
+- The "report ID" / "document number" appears made up.
+- The named survey / interviewee count cannot be traced.
+A draft full of citations that don't check out is worse than a draft
+that honestly writes "[\u9700\u8C03\u7814: ...]". Reward the latter.
+
+Aim for 8-20 critiques. Don't be polite \u2014 depth, missing sections, weak claims, and structural issues matter more than typos. Include PRAISE for genuinely strong parts so the author doesn't gut them on revision.
+
+Output strictly as JSON: {"critiques": [{...}, ...]}`;
+  },
+  argueUser(subject, draft, lens) {
+    return `Subject: ${subject.label}
+${lens ? `Review lens: ${lens}
+` : ""}
+Current document (v${draft.version}, by ${draft.author}):
+
+${draft.content}
+
+Now produce your critiques as JSON.`;
+  },
+  revisePrompt(subject, previous, critiques, minLength) {
+    return `You wrote v${previous.version}. Critics raised ${critiques.length} points.
+Rewrite the document as v${previous.version + 1}.
+
+Subject: ${subject.label}
+Description: ${subject.description}
+
+Current document (v${previous.version}):
+${previous.content}
+
+Critiques:
+${formatCritiquesForPrompt(critiques)}
+
+Rules:
+- ADDRESS every blocker and major. You may disagree, but say why in changelog.
+- Preserve PRAISE-tagged parts.
+- Expand sections that were called out as thin / missing examples / lacking evidence.
+- Output the COMPLETE new document (at least ${minLength} chars).
+
+Output format (literally \u2014 these markers will be parsed):
+
+<v_next_content>
+{full markdown document}
+</v_next_content>
+
+<v_next_meta>
+{
+  "acceptedCritiques": ["id1", "id2", ...],
+  "rejectedCritiques": [{"id": "id3", "reason": "..."}, ...],
+  "changelog": "what changed and why, in 1-3 short paragraphs"
+}
+</v_next_meta>`;
+  }
+};
+function getFormat(format) {
+  return format === "code" ? codeFormat : documentFormat;
+}
+
+// src/arena/iterate/phases/argue.ts
+init_esm_shims();
+
+// src/arena/iterate/parse.ts
+init_esm_shims();
+function extractTag(text, tag) {
+  const closed = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
+  const closedMatch = text.match(closed);
+  if (closedMatch) return closedMatch[1].trim();
+  const opener = new RegExp(`<${tag}>`, "i");
+  const openMatch = opener.exec(text);
+  if (!openMatch) return null;
+  const after = text.slice(openMatch.index + openMatch[0].length);
+  const nextTag = after.search(/<[a-z_][\w]*>/i);
+  const body = nextTag >= 0 ? after.slice(0, nextTag) : after;
+  return body.trim();
+}
+function parseMergeResponse(text) {
+  const content = extractTag(text, "v1_content");
+  const rationale = extractTag(text, "merge_rationale");
+  if (content) {
+    return { content, rationale: rationale ?? void 0 };
+  }
+  return { content: text.trim(), rationale: "[merge markers not found; using full response]" };
+}
+function parseReviseResponse(text) {
+  const content = extractTag(text, "v_next_content");
+  const metaRaw = extractTag(text, "v_next_meta");
+  let meta = {};
+  if (metaRaw) {
+    const cleaned = metaRaw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
+    try {
+      meta = JSON.parse(cleaned);
+    } catch {
+      meta = { changelog: `[meta JSON parse failed; raw text below]
+${metaRaw}` };
+    }
+  }
+  return {
+    content: content ?? text.trim(),
+    meta
+  };
+}
+function parseCritiquesResponse(text, criticName, idPrefix) {
+  const cleaned = text.replace(/^[^{[]*/, "").replace(/[^}\]]*$/, "").trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch {
+    const jsonMatch = text.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+    try {
+      parsed = JSON.parse(jsonMatch[0]);
+    } catch {
+      return [];
+    }
+  }
+  const arr = Array.isArray(parsed) ? parsed : parsed.critiques;
+  if (!Array.isArray(arr)) return [];
+  const out = [];
+  for (let i = 0; i < arr.length; i++) {
+    const c = arr[i];
+    if (!c.anchor || !c.comment) continue;
+    let evidence;
+    if (Array.isArray(c.evidence)) {
+      evidence = c.evidence.filter((e) => {
+        if (typeof e !== "object" || e === null) return false;
+        const obj = e;
+        return typeof obj.url === "string";
+      }).map((e) => ({ url: e.url, snippet: e.snippet }));
+      if (evidence.length === 0) evidence = void 0;
+    }
+    out.push({
+      id: `${idPrefix}-${criticName}-${i + 1}`,
+      critic: criticName,
+      anchor: String(c.anchor),
+      severity: c.severity ?? "minor",
+      category: c.category ?? "other",
+      comment: String(c.comment),
+      suggestion: c.suggestion ? String(c.suggestion) : void 0,
+      evidence
+    });
+  }
+  return out;
+}
+
+// src/arena/iterate/tools/web-tools.ts
+init_esm_shims();
+
+// src/tool-system/builtin/web-search.ts
+init_esm_shims();
+var webSearchToolDef = {
+  name: "WebSearch",
+  description: "Search the web for information. Returns a list of search results with titles, URLs, and snippets. Use this when you need up-to-date information or facts not in your training data.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "The search query" },
+      num_results: {
+        type: "number",
+        description: "Number of results to return (default: 10, max: 20)"
+      }
+    },
+    required: ["query"]
+  }
+};
+async function webSearchTool(args) {
+  const query = args.query;
+  if (!query) return "Error: query is required";
+  const numResults = Math.min(args.num_results || 10, 20);
+  const serperKey = process.env.SERPER_API_KEY;
+  const tavilyKey = process.env.TAVILY_API_KEY;
+  const searxngUrl = process.env.SEARXNG_URL;
+  try {
+    let results;
+    if (serperKey) {
+      results = await searchSerper(query, numResults, serperKey);
+    } else if (tavilyKey) {
+      results = await searchTavily(query, numResults, tavilyKey);
+    } else if (searxngUrl) {
+      results = await searchSearXNG(query, numResults, searxngUrl);
+    } else {
+      return "Error: No search API configured. Set one of: SERPER_API_KEY, TAVILY_API_KEY, or SEARXNG_URL";
+    }
+    if (results.length === 0) return "No results found.";
+    return results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet}`).join("\n\n");
+  } catch (err) {
+    return `Search error: ${err.message}`;
+  }
+}
+async function searchSerper(query, num, apiKey) {
+  const res = await fetch("https://google.serper.dev/search", {
+    method: "POST",
+    headers: {
+      "X-API-KEY": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ q: query, num })
+  });
+  if (!res.ok) throw new Error(`Serper API error: ${res.status} ${res.statusText}`);
+  const data = await res.json();
+  return (data.organic ?? []).map((item) => ({
+    title: item.title ?? "",
+    url: item.link ?? "",
+    snippet: item.snippet ?? ""
+  }));
+}
+async function searchTavily(query, num, apiKey) {
+  const res = await fetch("https://api.tavily.com/search", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      api_key: apiKey,
+      query,
+      max_results: num,
+      include_answer: false
+    })
+  });
+  if (!res.ok) throw new Error(`Tavily API error: ${res.status} ${res.statusText}`);
+  const data = await res.json();
+  return (data.results ?? []).map((item) => ({
+    title: item.title ?? "",
+    url: item.url ?? "",
+    snippet: item.content ?? ""
+  }));
+}
+async function searchSearXNG(query, num, baseUrl) {
+  const url = new URL("/search", baseUrl);
+  url.searchParams.set("q", query);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("pageno", "1");
+  const res = await fetch(url.toString(), {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) throw new Error(`SearXNG error: ${res.status} ${res.statusText}`);
+  const data = await res.json();
+  return (data.results ?? []).slice(0, num).map((item) => ({
+    title: item.title ?? "",
+    url: item.url ?? "",
+    snippet: item.content ?? ""
+  }));
+}
+
+// src/tool-system/builtin/web-fetch.ts
+init_esm_shims();
+var webFetchToolDef = {
+  name: "WebFetch",
+  description: "Fetch a web page and return its text content. Strips HTML tags to return readable text. Use this to read articles, documentation, or any web page.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "The URL to fetch" },
+      max_length: {
+        type: "number",
+        description: "Maximum characters to return (default: 50000)"
+      },
+      headers: {
+        type: "object",
+        description: "Optional HTTP headers to send"
+      }
+    },
+    required: ["url"]
+  }
+};
+var MAX_OUTPUT = 1e5;
+var DEFAULT_MAX = 5e4;
+var BLOCKED_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "authorization",
+  "cookie",
+  "proxy-authorization",
+  "x-forwarded-for",
+  "x-real-ip",
+  "x-forwarded-host"
+]);
+var BLOCKED_HOST_PATTERNS = [
+  /^localhost$/i,
+  /^127\./,
+  /^0\.0\.0\.0$/,
+  /^10\./,
+  /^169\.254\./,
+  // link-local + AWS/GCP metadata (169.254.169.254)
+  /^192\.168\./,
+  /^172\.(1[6-9]|2[0-9]|3[01])\./,
+  // 172.16.0.0/12
+  /^::1$/,
+  /^fc00:/i,
+  /^fd00:/i,
+  // IPv6 ULA
+  /^fe80:/i
+  // IPv6 link-local
+];
+function isBlockedHost(hostname) {
+  return BLOCKED_HOST_PATTERNS.some((re) => re.test(hostname));
+}
+async function webFetchTool(args) {
+  const url = args.url;
+  if (!url) return "Error: url is required";
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return `Error: invalid URL "${url}"`;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return `Error: only http(s) URLs are allowed, got "${parsed.protocol}"`;
+  }
+  if (isBlockedHost(parsed.hostname)) {
+    return `Error: refusing to fetch internal/loopback host "${parsed.hostname}"`;
+  }
+  const maxLength = Math.min(args.max_length || DEFAULT_MAX, MAX_OUTPUT);
+  const rawHeaders = args.headers ?? {};
+  const customHeaders = {};
+  for (const [k, v] of Object.entries(rawHeaders)) {
+    if (!BLOCKED_REQUEST_HEADERS.has(k.toLowerCase())) {
+      customHeaders[k] = v;
+    }
+  }
+  try {
+    const res = await fetch(url, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (compatible; code-shell/0.1; +https://github.com/nicepkg/code-shell)",
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8,*/*;q=0.7",
+        ...customHeaders
+      },
+      redirect: "follow",
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      return `Error: HTTP ${res.status} ${res.statusText}`;
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    const body = await res.text();
+    let text;
+    if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
+      text = extractTextFromHTML(body);
+    } else {
+      text = body;
+    }
+    if (text.length > maxLength) {
+      text = text.slice(0, maxLength) + `
+
+... content truncated (${text.length} chars total)`;
+    }
+    return text || "(page returned empty content)";
+  } catch (err) {
+    const msg = err.message;
+    if (msg.includes("abort") || msg.includes("timeout")) {
+      return "Error: request timed out after 30s";
+    }
+    return `Fetch error: ${msg}`;
+  }
+}
+function extractTextFromHTML(html) {
+  let text = html;
+  text = text.replace(/<script[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<noscript[\s\S]*?<\/noscript>/gi, "");
+  const titleMatch = text.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? decodeEntities(titleMatch[1].trim()) : "";
+  const mainMatch = text.match(/<main[\s\S]*?<\/main>/i) ?? text.match(/<article[\s\S]*?<\/article>/i) ?? text.match(/<div[^>]*(?:role="main"|id="content"|class="[^"]*content[^"]*")[^>]*>[\s\S]*?<\/div>/i);
+  if (mainMatch) {
+    text = mainMatch[0];
+  } else {
+    const bodyMatch = text.match(/<body[\s\S]*?<\/body>/i);
+    if (bodyMatch) text = bodyMatch[0];
+  }
+  text = text.replace(/<(nav|header|footer|aside)[\s\S]*?<\/\1>/gi, "");
+  text = text.replace(/<(p|div|h[1-6]|li|br|tr|blockquote)[^>]*>/gi, "\n");
+  text = text.replace(/<\/(p|div|h[1-6]|li|tr|blockquote)>/gi, "\n");
+  text = text.replace(/<hr[^>]*>/gi, "\n---\n");
+  text = text.replace(/<[^>]+>/g, "");
+  text = decodeEntities(text);
+  text = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  if (title) {
+    text = `# ${title}
+
+${text}`;
+  }
+  return text.trim();
+}
+function decodeEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n))).replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+}
+
+// src/arena/iterate/tools/web-tools.ts
+var webSearchToolDef2 = {
+  name: "web_search",
+  description: "Search the web (Google via Serper / Tavily / SearXNG depending on env). Use this to verify any specific number, citation, URL, library version, API name, or external claim made in the draft you are reviewing. If a claim cannot be verified by web_search, mark it as a fabrication critique with severity = blocker.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Search query (English usually works best)." },
+      num_results: { type: "number", description: "Default 5, max 20." }
+    },
+    required: ["query"]
+  }
+};
+var webFetchToolDef2 = {
+  name: "web_fetch",
+  description: "Fetch a URL and return its text content (HTML stripped). Use after web_search to read the actual page content of a search result and confirm a specific claim, version number, or quoted figure.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "Full http(s) URL to fetch." },
+      max_length: { type: "number", description: "Default 50000 characters." }
+    },
+    required: ["url"]
+  }
+};
+var ITERATE_WEB_TOOLS = [webSearchToolDef2, webFetchToolDef2];
+async function executeIterateWebTool(toolName, args) {
+  if (toolName === "web_search") {
+    return webSearchTool(args);
+  }
+  if (toolName === "web_fetch") {
+    return webFetchTool(args);
+  }
+  return `Error: unknown tool "${toolName}"`;
+}
+function hasWebSearchProvider() {
+  return Boolean(
+    process.env.SERPER_API_KEY || process.env.TAVILY_API_KEY || process.env.SEARXNG_URL
+  );
+}
+
+// src/arena/iterate/phases/argue.ts
+var DEFAULT_MAX_TOOL_ROUNDS = 8;
+async function runArgueRound(args) {
+  const { subject, format, draft, critics, round, enableWebSearch, maxToolRounds, signal, onProgress } = args;
+  onProgress?.({ type: "argue_start", round, data: { criticCount: critics.length } });
+  const wantWeb = Boolean(enableWebSearch);
+  const webAvailable = wantWeb && hasWebSearchProvider();
+  if (wantWeb && !webAvailable) {
+    logger.warn("arena.iterate.argue_web_unavailable", {
+      reason: "No SERPER_API_KEY / TAVILY_API_KEY / SEARXNG_URL configured"
+    });
+  }
+  const idPrefix = `r${round}`;
+  const tasks = critics.map(async (c) => {
+    signal?.throwIfAborted();
+    try {
+      if (webAvailable) {
+        return await argueWithToolLoop({
+          critic: c,
+          subject,
+          format,
+          draft,
+          idPrefix,
+          maxToolRounds: maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS,
+          signal
+        });
+      }
+      return await argueSingleShot({ critic: c, subject, format, draft, idPrefix, signal });
+    } catch (err) {
+      logger.warn("arena.iterate.argue_failed", {
+        round,
+        critic: c.name,
+        error: err.message
+      });
+      return [];
+    }
+  });
+  const results = await Promise.all(tasks);
+  const allCritiques = results.flat();
+  onProgress?.({
+    type: "argue_done",
+    round,
+    data: { critiqueCount: allCritiques.length, webEnabled: webAvailable }
+  });
+  return allCritiques;
+}
+async function argueSingleShot(args) {
+  const { critic, subject, format, draft, idPrefix, signal } = args;
+  const client = await createLLMClient({ ...critic.llm, enableStreaming: false });
+  const resp = await client.createMessage({
+    systemPrompt: format.argueSystem(format.format),
+    messages: [{ role: "user", content: format.argueUser(subject, draft) }],
+    tools: [],
+    signal
+  });
+  const critiques = parseCritiquesResponse(resp.text, critic.name, idPrefix);
+  logger.info("arena.iterate.argue_singleshot", {
+    critic: critic.name,
+    critiqueCount: critiques.length
+  });
+  return critiques;
+}
+async function argueWithToolLoop(args) {
+  const { critic, subject, format, draft, idPrefix, maxToolRounds, signal } = args;
+  const client = await createLLMClient({ ...critic.llm, enableStreaming: false });
+  const messages = [
+    { role: "user", content: format.argueUser(subject, draft) }
+  ];
+  let toolRounds = 0;
+  let finalText = "";
+  while (toolRounds < maxToolRounds) {
+    signal?.throwIfAborted();
+    const resp = await client.createMessage({
+      systemPrompt: format.argueSystem(format.format),
+      messages,
+      tools: ITERATE_WEB_TOOLS,
+      signal
+    });
+    if (resp.text) finalText = resp.text;
+    if (!resp.toolCalls || resp.toolCalls.length === 0) {
+      break;
+    }
+    messages.push({
+      role: "assistant",
+      content: [
+        ...resp.text ? [{ type: "text", text: resp.text }] : [],
+        ...resp.toolCalls.map((tc) => ({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.toolName,
+          input: tc.args
+        }))
+      ]
+    });
+    const toolResults = await Promise.all(
+      resp.toolCalls.map(async (tc) => {
+        try {
+          const result = await executeIterateWebTool(tc.toolName, tc.args);
+          return { id: tc.id, content: result };
+        } catch (err) {
+          return { id: tc.id, content: `Error: ${err.message}` };
+        }
+      })
+    );
+    messages.push({
+      role: "user",
+      content: toolResults.map((tr) => ({
+        type: "tool_result",
+        tool_use_id: tr.id,
+        content: tr.content
+      }))
+    });
+    toolRounds++;
+  }
+  if (!finalText && toolRounds >= maxToolRounds) {
+    const resp = await client.createMessage({
+      systemPrompt: format.argueSystem(format.format),
+      messages: [
+        ...messages,
+        {
+          role: "user",
+          content: "You have used the maximum number of tool rounds. Produce your critiques JSON now, based on what you have already gathered. Do not request any more tools."
+        }
+      ],
+      tools: [],
+      signal
+    });
+    finalText = resp.text;
+  }
+  const critiques = parseCritiquesResponse(finalText, critic.name, idPrefix);
+  logger.info("arena.iterate.argue_toolloop", {
+    critic: critic.name,
+    critiqueCount: critiques.length,
+    toolRounds
+  });
+  return critiques;
+}
+
+// src/arena/iterate/phases/revise.ts
+init_esm_shims();
+async function runRevise(args) {
+  const { subject, format, previous, critiques, author, minDraftLength, signal, onProgress } = args;
+  onProgress?.({ type: "revise_start", round: previous.version + 1, participant: author.name });
+  const client = await createLLMClient({ ...author.llm, enableStreaming: false });
+  const prompt = format.revisePrompt(subject, previous, critiques, minDraftLength);
+  const resp = await client.createMessage({
+    systemPrompt: prompt,
+    messages: [{ role: "user", content: `Produce v${previous.version + 1} now.` }],
+    tools: [],
+    maxTokens: 32e3,
+    signal
+  });
+  const { content, meta } = parseReviseResponse(resp.text);
+  let acceptedContent = content;
+  const shrinkage = previous.content.length > 0 ? 1 - acceptedContent.length / previous.content.length : 0;
+  if (shrinkage > 0.3 && acceptedContent.length < minDraftLength) {
+    logger.warn("arena.iterate.revise_too_short", {
+      version: previous.version + 1,
+      previousLength: previous.content.length,
+      newLength: acceptedContent.length,
+      minDraftLength
+    });
+    meta.changelog = `[WARNING: revision is ${Math.round(shrinkage * 100)}% shorter than v${previous.version}; the author may have summarized instead of rewriting]
+
+` + (meta.changelog ?? "");
+  }
+  const next = {
+    version: previous.version + 1,
+    author: author.name,
+    format: format.format,
+    content: acceptedContent,
+    acceptedCritiques: meta.acceptedCritiques,
+    rejectedCritiques: meta.rejectedCritiques,
+    changelog: meta.changelog
+  };
+  onProgress?.({
+    type: "revise_done",
+    round: next.version,
+    participant: author.name,
+    data: { length: acceptedContent.length, accepted: meta.acceptedCritiques?.length ?? 0 }
+  });
+  logger.info("arena.iterate.revise", {
+    version: next.version,
+    author: author.name,
+    length: acceptedContent.length,
+    accepted: meta.acceptedCritiques?.length ?? 0,
+    rejected: meta.rejectedCritiques?.length ?? 0
+  });
+  return next;
+}
+
+// src/arena/iterate/phases/tournament.ts
+init_esm_shims();
+async function runTournamentCandidates(args) {
+  const { subject, format, participants, minDraftLength, signal, onProgress } = args;
+  onProgress?.({ type: "v1_tournament_start", data: { count: participants.length } });
+  const tasks = participants.map(async (p, idx) => {
+    signal?.throwIfAborted();
+    const client = await createLLMClient({ ...p.llm, enableStreaming: false });
+    const prompt = format.draftPrompt(subject, minDraftLength);
+    const resp = await client.createMessage({
+      systemPrompt: prompt,
+      messages: [{ role: "user", content: `Write your draft now.` }],
+      tools: [],
+      maxTokens: 32e3,
+      signal
+    });
+    const content = resp.text.trim();
+    const candidate = {
+      author: p.name,
+      anonymousLabel: `Draft ${String.fromCharCode(65 + idx)}`,
+      // A, B, C...
+      content
+    };
+    onProgress?.({
+      type: "v1_candidate_done",
+      participant: p.name,
+      data: { length: content.length, anonymousLabel: candidate.anonymousLabel }
+    });
+    logger.info("arena.iterate.v1_candidate", {
+      participant: p.name,
+      anonymousLabel: candidate.anonymousLabel,
+      length: content.length
+    });
+    return candidate;
+  });
+  const settled = await Promise.allSettled(tasks);
+  const candidates = [];
+  for (const s of settled) {
+    if (s.status === "fulfilled") candidates.push(s.value);
+    else logger.warn("arena.iterate.v1_candidate_failed", { error: s.reason?.message });
+  }
+  if (candidates.length === 0) {
+    throw new Error("All v1 tournament candidates failed");
+  }
+  for (let i = candidates.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [candidates[i], candidates[j]] = [candidates[j], candidates[i]];
+    candidates[i].anonymousLabel = `Draft ${String.fromCharCode(65 + i)}`;
+  }
+  candidates[0].anonymousLabel = `Draft A`;
+  return candidates;
+}
+async function mergeCandidatesToV1(args) {
+  const { subject, format, author, candidates, minDraftLength, signal, onProgress } = args;
+  onProgress?.({ type: "v1_merge_start", participant: author.name });
+  const client = await createLLMClient({ ...author.llm, enableStreaming: false });
+  const prompt = format.mergePrompt(subject, candidates, minDraftLength);
+  const resp = await client.createMessage({
+    systemPrompt: prompt,
+    messages: [{ role: "user", content: `Produce v1 now.` }],
+    tools: [],
+    maxTokens: 32e3,
+    signal
+  });
+  const { content, rationale } = parseMergeResponse(resp.text);
+  const draft = {
+    version: 1,
+    author: author.name,
+    format: format.format,
+    content,
+    draftCandidates: candidates,
+    mergeRationale: rationale
+  };
+  onProgress?.({ type: "v1_merge_done", participant: author.name, data: { length: content.length } });
+  logger.info("arena.iterate.v1_merge", {
+    author: author.name,
+    candidateCount: candidates.length,
+    length: content.length
+  });
+  return draft;
+}
+async function singleAuthorV1(args) {
+  const { subject, format, author, minDraftLength, signal } = args;
+  const client = await createLLMClient({ ...author.llm, enableStreaming: false });
+  const prompt = format.draftPrompt(subject, minDraftLength);
+  const resp = await client.createMessage({
+    systemPrompt: prompt,
+    messages: [{ role: "user", content: `Write your draft now.` }],
+    tools: [],
+    maxTokens: 32e3,
+    signal
+  });
+  return {
+    version: 1,
+    author: author.name,
+    format: format.format,
+    content: resp.text.trim()
+  };
+}
+
+// src/arena/iterate/iterative-arena.ts
+var DEFAULT_MAX_ROUNDS = 5;
+var IterativeArena = class {
+  config;
+  constructor(config) {
+    if (!config.author) {
+      throw new Error("IterativeArena requires an `author` participant");
+    }
+    if (!config.critics || config.critics.length === 0) {
+      throw new Error("IterativeArena requires at least 1 critic");
+    }
+    const allNames = [config.author.name, ...config.critics.map((c) => c.name)];
+    if (new Set(allNames).size !== allNames.length) {
+      throw new Error("Author and critics must have unique names");
+    }
+    this.config = config;
+  }
+  async run() {
+    const start = Date.now();
+    const { config } = this;
+    const format = getFormat(config.format);
+    const maxRounds = config.maxRounds ?? DEFAULT_MAX_ROUNDS;
+    const minDraftLength = config.minDraftLength ?? (config.format === "code" ? 200 : 800);
+    const signal = config.signal;
+    const rounds = [];
+    let currentDraft;
+    try {
+      if ((config.v1Strategy ?? "tournament") === "tournament") {
+        const candidates = await runTournamentCandidates({
+          subject: config.subject,
+          format,
+          participants: [config.author, ...config.critics],
+          minDraftLength,
+          signal,
+          onProgress: config.onProgress
+        });
+        currentDraft = await mergeCandidatesToV1({
+          subject: config.subject,
+          format,
+          author: config.author,
+          candidates,
+          minDraftLength,
+          signal,
+          onProgress: config.onProgress
+        });
+      } else {
+        currentDraft = await singleAuthorV1({
+          subject: config.subject,
+          format,
+          author: config.author,
+          minDraftLength,
+          signal
+        });
+      }
+    } catch (err) {
+      logger.error("arena.iterate.v1_failed", { error: err.message });
+      throw err;
+    }
+    let currentAuthor = config.author;
+    const pool = [config.author, ...config.critics];
+    let previousDraft;
+    for (let r = 1; r <= maxRounds; r++) {
+      signal?.throwIfAborted();
+      const critiques = await runArgueRound({
+        subject: config.subject,
+        format,
+        draft: currentDraft,
+        critics: this.criticsForRound(r),
+        round: r,
+        enableWebSearch: config.enableWebSearch,
+        maxToolRounds: config.maxArgueToolRounds,
+        signal,
+        onProgress: config.onProgress
+      });
+      const convergence = this.checkConvergence({
+        round: r,
+        critiques,
+        draft: currentDraft,
+        previousDraft
+      });
+      const round = {
+        round: r,
+        draft: currentDraft,
+        critiques,
+        convergence
+      };
+      let userAction;
+      if (config.humanCheckpoint) {
+        config.onProgress?.({ type: "checkpoint_pause", round: r });
+        userAction = await config.humanCheckpoint({
+          round: r,
+          draft: currentDraft,
+          critiques,
+          convergence
+        });
+      }
+      rounds.push(round);
+      config.onProgress?.({
+        type: "round_done",
+        round: r,
+        data: {
+          critiques: critiques.length,
+          shouldStop: convergence.shouldStop,
+          userAction
+        }
+      });
+      if (userAction === "stop") {
+        return this.finalize(rounds, "user_stop", start);
+      }
+      if (userAction !== "force-continue" && convergence.shouldStop) {
+        return this.finalize(rounds, "converged", start);
+      }
+      if (r === maxRounds) {
+        return this.finalize(rounds, "max_rounds", start);
+      }
+      previousDraft = currentDraft;
+      currentAuthor = this.pickNextAuthor(currentAuthor, critiques, pool, r);
+      currentDraft = await runRevise({
+        subject: config.subject,
+        format,
+        previous: previousDraft,
+        critiques,
+        author: currentAuthor,
+        minDraftLength,
+        signal,
+        onProgress: config.onProgress
+      });
+    }
+    return this.finalize(rounds, "max_rounds", start);
+  }
+  /** Critics for a given round = pool minus current author (so author isn't critiquing self). */
+  criticsForRound(_round) {
+    return this.config.critics;
+  }
+  checkConvergence(args) {
+    if (this.config.convergenceStrategy && this.config.convergenceStrategy !== "default") {
+      const stop = this.config.convergenceStrategy(args);
+      const blockerCount = args.critiques.filter((c) => c.severity === "blocker").length;
+      const majorCount = args.critiques.filter((c) => c.severity === "major").length;
+      const diffFromPrevious = args.previousDraft ? diffRatio(args.previousDraft.content, args.draft.content) : 1;
+      return {
+        blockerCount,
+        majorCount,
+        totalCritiques: args.critiques.length,
+        diffFromPrevious,
+        shouldStop: stop,
+        reason: stop ? "all_minor_or_praise" : "running"
+      };
+    }
+    return defaultConvergence(args);
+  }
+  pickNextAuthor(current, critiques, pool, round) {
+    const policy = this.config.authorRotation ?? "fixed";
+    if (policy === "fixed") return this.config.author;
+    if (policy === "round-robin") {
+      const idx = round % pool.length;
+      return pool[idx];
+    }
+    if (policy === "best-critic") {
+      const sevWeight = {
+        blocker: 5,
+        major: 3,
+        minor: 1,
+        nit: 0.5,
+        praise: 0
+      };
+      const scores = /* @__PURE__ */ new Map();
+      for (const c of critiques) {
+        scores.set(c.critic, (scores.get(c.critic) ?? 0) + (sevWeight[c.severity] ?? 0));
+      }
+      let best = current.name;
+      let bestScore = -1;
+      for (const [name, score] of scores) {
+        if (score > bestScore) {
+          bestScore = score;
+          best = name;
+        }
+      }
+      const winner = pool.find((p) => p.name === best);
+      return winner ?? current;
+    }
+    return current;
+  }
+  finalize(rounds, stoppedAt, start) {
+    const finalDraft = rounds.at(-1).draft;
+    const result = {
+      subject: this.config.subject,
+      format: this.config.format,
+      rounds,
+      finalDraft,
+      stoppedAt,
+      durationMs: Date.now() - start
+    };
+    this.config.onProgress?.({
+      type: "iterate_complete",
+      data: {
+        stoppedAt,
+        rounds: rounds.length,
+        finalLength: finalDraft.content.length
+      }
+    });
+    logger.info("arena.iterate.complete", {
+      stoppedAt,
+      rounds: rounds.length,
+      finalVersion: finalDraft.version,
+      finalLength: finalDraft.content.length
+    });
+    return result;
+  }
+};
+
+export {
+  webSearchToolDef,
+  webSearchTool,
+  webFetchToolDef,
+  webFetchTool,
+  diffRatio,
+  defaultConvergence,
+  codeFormat,
+  documentFormat,
+  getFormat,
+  IterativeArena
+};