@awi-protocol/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -31,10 +31,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AWIClient: () => AWIClient,
-  AWIError: () => AWIError,
+  AXIRCompiler: () => AXIRCompiler,
   AdvisoryExecutor: () => AdvisoryExecutor,
-  LocalAXIRCompiler: () => LocalAXIRCompiler,
-  default: () => client_default
+  LocalAXIRCompiler: () => LocalAXIRCompiler
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -242,7 +241,6 @@ var AWIClient = class {
     throw lastError || new AWIError("MAX_RETRIES", "Max retries exceeded", 502);
   }
 };
-var client_default = AWIClient;
 
 // src/advisory-executor.ts
 var AdvisoryExecutor = class {
@@ -473,27 +471,312 @@ var AdvisoryExecutor = class {
   }
 };
 
+// src/compiler/axir-compiler.ts
+var cheerio = __toESM(require("cheerio"));
+var AXIRCompiler = class {
+  $;
+  intent;
+  params;
+  domain;
+  constructor(html, options) {
+    this.$ = cheerio.load(html);
+    this.intent = options.intent;
+    this.params = options.params || {};
+    this.domain = options.domain || "unknown";
+  }
+  compile() {
+    const start = Date.now();
+    this.simplifyDOM();
+    const regions = this.identifyRegions();
+    const target = this.routeIntent(regions);
+    return {
+      workflow: this.buildWorkflow(target, regions),
+      intents: this.mapIntents(),
+      selectors: this.generateSelectors(target),
+      fields: this.generateFields(target),
+      container: target.container,
+      model_used: "axir-deterministic-v1",
+      tokens_used: 0,
+      compilation_time_ms: Date.now() - start
+    };
+  }
+  simplifyDOM() {
+    this.$("script, style, svg, noscript, iframe, canvas, video, audio").remove();
+    for (const el of this.$("div, span").toArray()) {
+      const $el = this.$(el);
+      if ($el.children().length === 0 && $el.text().trim() === "") $el.remove();
+    }
+    this.$('[style*="display:none"], [style*="display: none"], [hidden], [aria-hidden="true"]').remove();
+  }
+  identifyRegions() {
+    const regions = [];
+    for (const el of this.$('form, [role="search"], input[type="search"]').toArray()) {
+      const r = this.analyzeSearchRegion(this.$(el));
+      if (r) regions.push(r);
+    }
+    for (const el of this.$('nav, [role="navigation"], header, .nav, .navbar, .menu').toArray()) {
+      regions.push({ type: "navigation", element: this.$(el), confidence: 0.9 });
+    }
+    for (const el of this.$('ul, ol, [role="list"], .list, .results, .items, table, [role="grid"]').toArray()) {
+      const $el = this.$(el);
+      if ($el.find('li, tr, .item, [role="listitem"]').length > 1) {
+        regions.push({ type: "listing", element: $el, confidence: 0.85 });
+      }
+    }
+    for (const el of this.$("form").toArray()) {
+      const $el = this.$(el);
+      if (!regions.some((r) => r.element.is($el))) regions.push({ type: "form", element: $el, confidence: 0.9 });
+    }
+    for (const el of this.$(".pagination, .pager, .pages").toArray()) {
+      if (this.isPagination(this.$(el))) regions.push({ type: "pagination", element: this.$(el), confidence: 0.8 });
+    }
+    for (const el of this.$('article, [role="article"], .content, .main, main, .detail').toArray()) {
+      regions.push({ type: "detail", element: this.$(el), confidence: 0.75 });
+    }
+    return regions;
+  }
+  analyzeSearchRegion($el) {
+    const hasInput = $el.find('input[type="text"], input[type="search"], input:not([type])').length > 0;
+    const hasButton = $el.find('button, input[type="submit"]').length > 0;
+    if (hasInput || hasButton) return { type: "search", element: $el, confidence: hasInput && hasButton ? 0.95 : 0.7 };
+    return null;
+  }
+  isPagination($el) {
+    const text = $el.text().toLowerCase();
+    return /\d+/.test(text) && (/next|>|\u203a|\u2192|\u00bb/.test(text) || /prev|previous|<|\u2039|\u2190|\u00ab/.test(text));
+  }
+  routeIntent(regions) {
+    const intentMap = {
+      search: ["search", "form"],
+      search_jobs: ["search", "listing", "form"],
+      extract_list: ["listing", "search", "detail"],
+      extract_detail: ["detail", "listing"],
+      fill_form: ["form", "search"],
+      navigate: ["navigation", "listing"],
+      login: ["form"],
+      filter: ["search", "listing"],
+      sort: ["listing", "search"],
+      scrape: ["listing", "detail", "search"]
+    };
+    const targetTypes = intentMap[this.intent.toLowerCase()] || ["search", "listing", "form"];
+    let best = null;
+    let bestScore = 0;
+    for (const r of regions) {
+      const match = targetTypes.indexOf(r.type);
+      const score = match >= 0 ? (targetTypes.length - match) * r.confidence : 0;
+      if (score > bestScore) {
+        bestScore = score;
+        best = r;
+      }
+    }
+    if (!best) best = this.findLargestRegion(regions);
+    return { region: best, container: this.generateContainerSelector(best.element) };
+  }
+  findLargestRegion(regions) {
+    if (regions.length === 0) return { type: "unknown", element: this.$("body"), confidence: 0.5 };
+    return regions.reduce((l, c) => c.element.find("*").length > l.element.find("*").length ? c : l);
+  }
+  buildWorkflow(_target, all) {
+    const nodes = {};
+    const edges = [];
+    const entry = [];
+    const exit = [];
+    all.forEach((r, i) => {
+      const id = `${r.type}_${i}`;
+      const raw = r.element[0];
+      nodes[id] = {
+        node_id: id,
+        element_type: this.mapType(r.type),
+        semantic_role: r.type,
+        intent: this.intent,
+        tag: raw?.tagName?.toLowerCase(),
+        selector_candidates: this.buildCandidates(r.element),
+        confidence: r.confidence
+      };
+      if (r.type === "navigation") entry.push(id);
+      if (r.type === "listing" || r.type === "detail") exit.push(id);
+    });
+    all.forEach((f, fi) => all.forEach((t, ti) => {
+      if (fi !== ti) {
+        const e = this.inferEdge(f, t, fi, ti);
+        if (e) edges.push(e);
+      }
+    }));
+    if (entry.length === 0 && Object.keys(nodes).length > 0) entry.push(Object.keys(nodes)[0]);
+    return { nodes, edges, entry_points: entry, exit_points: exit, domain: this.domain, page_type: this.inferPageType(all) };
+  }
+  mapType(t) {
+    const m = {
+      search: "search",
+      navigation: "navigation",
+      listing: "list",
+      form: "form",
+      pagination: "pagination",
+      detail: "container"
+    };
+    return m[t] || "unknown";
+  }
+  inferEdge(f, t, fi, ti) {
+    if (f.type === "search" && t.type === "listing") return { from_node: `search_${fi}`, to_node: `listing_${ti}`, action: "submit_search", probability: 0.9 };
+    if (f.type === "navigation" && t.type === "search") return { from_node: `navigation_${fi}`, to_node: `search_${ti}`, action: "navigate_to_search", probability: 0.7 };
+    if (f.type === "listing" && t.type === "pagination") return { from_node: `listing_${fi}`, to_node: `pagination_${ti}`, action: "next_page", probability: 0.8 };
+    if (f.type === "pagination" && t.type === "listing") return { from_node: `pagination_${fi}`, to_node: `listing_${ti}`, action: "load_results", probability: 0.95 };
+    return null;
+  }
+  inferPageType(regions) {
+    const t = regions.map((r) => r.type);
+    if (t.includes("search") && t.includes("listing")) return "search";
+    if (t.includes("listing")) return "listing";
+    if (t.includes("form")) return "form";
+    if (t.includes("search")) return "search";
+    if (t.includes("navigation")) return "landing";
+    return "unknown";
+  }
+  generateSelectors(target) {
+    const s = {};
+    const $el = target.region.element;
+    s.container = this.buildCandidates($el);
+    for (const el of $el.find("input, textarea, select").toArray()) {
+      const n = this.inferFieldName(this.$(el));
+      if (n) s[n] = this.buildCandidates(this.$(el));
+    }
+    for (const el of $el.find('button, input[type="submit"], input[type="button"]').toArray()) {
+      const $btn = this.$(el);
+      const label = $btn.text().trim() || String($btn.val() || "button");
+      s[`btn_${this.slugify(label)}`] = this.buildCandidates($btn);
+    }
+    for (const el of $el.find("a").toArray()) {
+      const $a = this.$(el);
+      const t = $a.text().trim();
+      if (t && t.length < 50) s[`link_${this.slugify(t)}`] = this.buildCandidates($a);
+    }
+    return s;
+  }
+  buildCandidates($el) {
+    const c = [];
+    const el = $el[0];
+    if (!el) return c;
+    const id = $el.attr("id");
+    if (id && !id.match(/^\d/)) c.push({ type: "css", value: `#${this.escape(id)}`, priority: 1, confidence: 0.99 });
+    const classes = ($el.attr("class") || "").split(/\s+/).filter((x) => x && !x.match(/^js-|^ng-|^vue-|^data-/));
+    if (classes.length) c.push({ type: "css", value: `.${classes.map((x) => this.escape(x)).join(".")}`, priority: 2, confidence: 0.85 });
+    const raw = el;
+    const tag = raw.tagName?.toLowerCase() || "";
+    const name = $el.attr("name");
+    const type = $el.attr("type");
+    const placeholder = $el.attr("placeholder");
+    if (name) c.push({ type: "css", value: `${tag}[name="${this.q(name)}"]`, priority: 3, confidence: 0.9 });
+    if (type) c.push({ type: "css", value: `${tag}[type="${type}"]`, priority: 4, confidence: 0.8 });
+    if (placeholder) c.push({ type: "css", value: `${tag}[placeholder="${this.q(placeholder)}"]`, priority: 5, confidence: 0.75 });
+    const role = $el.attr("role");
+    if (role) c.push({ type: "semantic", value: `[role="${role}"]`, priority: 6, confidence: 0.9 });
+    const al = $el.attr("aria-label");
+    if (al) c.push({ type: "semantic", value: `[aria-label="${this.q(al)}"]`, priority: 7, confidence: 0.85 });
+    const text = $el.text().trim();
+    if (text && text.length < 100) c.push({ type: "text", value: text, priority: 8, confidence: 0.7 });
+    return c;
+  }
+  generateFields(target) {
+    const f = [];
+    for (const el of target.region.element.find("input, textarea, select").toArray()) {
+      const $el = this.$(el);
+      const name = this.inferFieldName($el);
+      if (!name) continue;
+      f.push({
+        name,
+        selector: this.bestSelector($el),
+        transform: this.inferTransform($el),
+        required: $el.attr("required") !== void 0
+      });
+    }
+    return f;
+  }
+  inferFieldName($el) {
+    const id = $el.attr("id");
+    if (id) {
+      const $l = this.$(`label[for="${id}"]`);
+      if ($l.length) return this.slugify($l.text());
+    }
+    const ph = $el.attr("placeholder");
+    if (ph) return this.slugify(ph);
+    const al = $el.attr("aria-label");
+    if (al) return this.slugify(al);
+    const n = $el.attr("name");
+    if (n) return this.slugify(n);
+    return null;
+  }
+  inferTransform($el) {
+    const t = $el.attr("type");
+    if (t === "number") return "number";
+    if (t === "email") return "email";
+    if (t === "date") return "date";
+    if (t === "checkbox") return "boolean";
+    if ($el.is("select")) return "select";
+    return void 0;
+  }
+  bestSelector($el) {
+    const c = this.buildCandidates($el);
+    if (c.length) return c[0].value;
+    const raw = $el[0];
+    return raw?.tagName?.toLowerCase() || "*";
+  }
+  generateContainerSelector($el) {
+    const c = this.buildCandidates($el);
+    return c.length ? c[0].value : "body";
+  }
+  mapIntents() {
+    const m = {
+      search: { intent: "search", action: "fill_and_submit", parameters: ["query", "location", "filters"], context: "Enter search terms and submit form" },
+      search_jobs: { intent: "search_jobs", action: "fill_and_submit", parameters: ["query", "location", "experience_level", "job_type"], context: "Search for job listings with optional filters" },
+      extract_list: { intent: "extract_list", action: "extract_fields", parameters: ["items", "title", "url", "metadata"], context: "Extract structured data from list items" },
+      extract_detail: { intent: "extract_detail", action: "extract_fields", parameters: ["title", "description", "metadata", "links"], context: "Extract structured data from detail page" },
+      fill_form: { intent: "fill_form", action: "fill_and_submit", parameters: Object.keys(this.params), context: "Fill form fields with provided parameters" },
+      navigate: { intent: "navigate", action: "click", parameters: ["target_url", "link_text"], context: "Click navigation link to target page" },
+      login: { intent: "login", action: "fill_and_submit", parameters: ["username", "password"], context: "Enter credentials and submit login form" },
+      scrape: { intent: "scrape", action: "extract_fields", parameters: ["all_visible_text", "links", "images", "structured_data"], context: "Extract all visible content from the page" }
+    };
+    const mapped = m[this.intent.toLowerCase()];
+    if (mapped) return [mapped];
+    return [{ intent: this.intent, action: "interact", parameters: Object.keys(this.params), context: `Perform ${this.intent} on the page` }];
+  }
+  slugify(t) {
+    return t.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "_").replace(/^_|_$/g, "").substring(0, 50);
+  }
+  escape(s) {
+    return s.replace(/([:.])/g, "\\$1");
+  }
+  q(s) {
+    return s.replace(/"/g, '\\"');
+  }
+};
+
 // src/compiler/local-axir.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
 var https = __toESM(require("https"));
 var http = __toESM(require("http"));
-
-// src/compiler/grammar/axir-schema.gbnf
-var axir_schema_default = 'root ::= "{" ws axir-fields ws "}"\n\naxir-fields ::=\n  "\\"workflow\\"" ":" workflow ws ","\n  ws "\\"intents\\"" ":" intents ws ","\n  ws "\\"selectors\\"" ":" selectors ws ","\n  ws "\\"fields\\"" ":" fields\n  ["," ws "\\"container\\"" ":" string]\n  ["," ws "\\"model_used\\"" ":" string]\n  ["," ws "\\"tokens_used\\"" ":" number]\n  ["," ws "\\"compilation_time_ms\\"" ":" number]\n\nworkflow ::=\n  "{" ws\n    "\\"nodes\\"" ":" "{" ws node-list ws "}" ws ","\n    ws "\\"edges\\"" ":" "[" ws edge-list ws "]" ws ","\n    ws "\\"entry_points\\"" ":" "[" ws string-list ws "]" ws ","\n    ws "\\"exit_points\\"" ":" "[" ws string-list ws "]" ws ","\n    ws "\\"domain\\"" ":" string ws ","\n    ws "\\"page_type\\"" ":" page-type\n    ["," ws "\\"structure_hash\\"" ":" string]\n  ws "}"\n\nnode-list ::= [node-pair ("," ws node-pair)*]\nnode-pair ::= string ":" "{" ws\n  "\\"element_type\\"" ":" element-type ws ","\n  ws "\\"semantic_role\\"" ":" string ws ","\n  ws "\\"intent\\"" ":" string ws ","\n  ws "\\"tag\\"" ":" string ws ","\n  ws "\\"selector_candidates\\"" ":" "[" ws selector-list ws "]"\n  ["," ws "\\"parent_id\\"" ":" string]\n  ["," ws "\\"children_ids\\"" ":" "[" ws string-list ws "]"]\n  ["," ws "\\"aria_label\\"" ":" string]\n  ["," ws "\\"aria_role\\"" ":" string]\n  ["," ws "\\"text_content\\"" ":" string]\n  "," ws "\\"confidence\\"" ":" number\n  ["," ws "\\"reasoning\\"" ":" string]\nws "}"\n\nelement-type ::=\n  "\\"button\\"" | "\\"link\\"" | "\\"input\\"" | "\\"form\\"" |\n  "\\"navigation\\"" | "\\"search\\"" | "\\"filter\\"" | "\\"sort\\"" |\n  "\\"pagination\\"" | "\\"container\\"" | "\\"list\\"" | "\\"item\\"" |\n  "\\"heading\\"" | "\\"text\\"" | "\\"image\\"" | "\\"unknown\\""\n\npage-type ::=\n  "\\"landing\\"" | "\\"search\\"" | "\\"listing\\"" | "\\"detail\\"" |\n  "\\"form\\"" | "\\"checkout\\"" | "\\"dashboard\\"" | "\\"unknown\\""\n\nedge-list ::= [edge ("," ws edge)*]\nedge ::= "{" ws\n  "\\"from_node\\"" ":" string ws ","\n  ws "\\"to_node\\"" ":" string ws ","\n  ws "\\"action\\"" ":" string\n  ["," ws "\\"condition\\"" ":" string]\n  ["," ws "\\"probability\\"" ":" number]\nws "}"\n\nselector-list ::= [selector ("," ws selector)*]\nselector ::= "{" ws\n  "\\"type\\"" ":" selector-type ws ","\n  ws "\\"value\\"" ":" string ws ","\n  ws "\\"priority\\"" ":" number\n  ["," ws "\\"confidence\\"" ":" number]\nws "}"\n\nselector-type ::= "\\"css\\"" | "\\"semantic\\"" | "\\"text\\"" | "\\"attribute\\""\n\nintents ::= "[" ws [intent ("," ws intent)*] ws "]"\nintent ::= "{" ws\n  "\\"intent\\"" ":" string ws ","\n  ws "\\"action\\"" ":" string ws ","\n  ws "\\"parameters\\"" ":" "[" ws [string ("," ws string)*] ws "]" ws ","\n  ws "\\"context\\"" ":" string\nws "}"\n\nfields ::= "[" ws [field ("," ws field)*] ws "]"\nfield ::= "{" ws\n  "\\"name\\"" ":" string ws ","\n  ws "\\"selector\\"" ":" string\n  ["," ws "\\"transform\\"" ":" string]\n  ["," ws "\\"required\\"" ":" boolean]\nws "}"\n\nselectors ::= "{" ws [selector-pair ("," ws selector-pair)*] ws "}"\nselector-pair ::= string ":" "[" ws selector-list ws "]"\n\nstring-list ::= [string ("," ws string)*]\n\nstring ::= "\\"" char* "\\""\nchar ::= [^"\\\\] | "\\\\" (["\\\\/bfnrt] | "u" [0-9a-fA-F]{4})\n\nnumber ::= ["-"]? ("0" | [1-9] [0-9]*) ([.] [0-9]+)? ([eE] ["-"]? [0-9]+)?\n\nboolean ::= "true" | "false"\n\nws ::= [ \\t\\n\\r]*\n';
-
-// src/compiler/local-axir.ts
+var import_url = require("url");
 var nativeAvailable = false;
 var getLlama;
-try {
-  const llama = require("node-llama-cpp");
-  getLlama = llama.getLlama;
+var LlamaModel;
+var LlamaContext;
+var LlamaGrammar;
+var llamaPromise = import("node-llama-cpp").then((m) => {
   nativeAvailable = true;
-} catch {
+  getLlama = m.getLlama;
+  LlamaModel = m.LlamaModel;
+  LlamaContext = m.LlamaContext;
+  LlamaGrammar = m.LlamaGrammar;
+  return m;
+}).catch((err) => {
   nativeAvailable = false;
-}
-var DEFAULT_MODEL_URL = "https://huggingface.co/bartowski/Phi-3-mini-128k-instruct-GGUF/resolve/main/Phi-3-mini-128k-instruct-Q4_K_M.gguf";
+  if (process.env.AWI_DEBUG) {
+    console.error("[AWI] node-llama-cpp load error:", err.message);
+  }
+  return null;
+});
+var DEFAULT_MODEL_URL = "https://github.com/RayAKaan/AWI/releases/download/v0.0.0-models/Phi-3-mini-128k-instruct-Q4_K_M.gguf";
 var DEFAULT_MODEL_FILENAME = "phi3-128k-q4.gguf";
 var LocalAXIRCompiler = class {
   modelPath;
@@ -520,9 +803,6 @@ var LocalAXIRCompiler = class {
     this.onDownloadProgress = options.onDownloadProgress;
     this.onStatus = options.onStatus;
   }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
   async compile(domHTML, a11yTree, intent, params) {
     await this._ensureModel();
     await this._ensureGrammar();
@@ -569,22 +849,26 @@ var LocalAXIRCompiler = class {
       this.ready = false;
     }
   }
-  // -------------------------------------------------------------------------
-  // Model lifecycle
-  // -------------------------------------------------------------------------
   async _ensureModel() {
     if (this.ready) return;
+    await llamaPromise;
+    if (!getLlama) {
+      throw new Error("node-llama-cpp failed to load. Is it installed?");
+    }
     if (!fs.existsSync(this.modelPath)) {
       await this._downloadModel();
     }
     this._status("Loading local model...");
     const llama = await getLlama();
     const gpuLayers = this.gpuLayers ?? this._autoDetectGPULayers();
-    this.model = new llama.LlamaModel({
+    this.model = new LlamaModel({
+      llama,
       modelPath: this.modelPath,
       gpuLayers
     });
-    this.context = await this.model.createContext({
+    this.context = new LlamaContext({
+      llama,
+      model: this.model,
       contextSize: this.contextSize
     });
     this.ready = true;
@@ -592,9 +876,10 @@ var LocalAXIRCompiler = class {
   }
   async _ensureGrammar() {
     if (this.grammar) return;
-    const llama = await getLlama();
-    this.grammar = new llama.LlamaGrammar({
-      grammar: axir_schema_default
+    const grammarPath = path.join(__dirname, "grammar", "axir-schema.gbnf");
+    this.grammar = new LlamaGrammar({
+      llama: await getLlama(),
+      grammar: fs.readFileSync(grammarPath, "utf-8")
     });
   }
   _autoDetectGPULayers() {
@@ -603,17 +888,14 @@ var LocalAXIRCompiler = class {
     }
     return 0;
   }
-  // -------------------------------------------------------------------------
-  // Resumable model download
-  // -------------------------------------------------------------------------
   async _downloadModel() {
     const dir = path.dirname(this.modelPath);
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true });
     }
     const tempPath = `${this.modelPath}.tmp`;
-    const urlObj = new URL(this.modelUrl);
-    const protocol = urlObj.protocol === "https:" ? https : http;
+    const url = new import_url.URL(this.modelUrl);
+    const protocol = url.protocol === "https:" ? https : http;
     let startByte = 0;
     if (fs.existsSync(tempPath)) {
       startByte = fs.statSync(tempPath).size;
@@ -629,10 +911,10 @@ var LocalAXIRCompiler = class {
         headers["Range"] = `bytes=${startByte}-`;
       }
       const request = protocol.get(
-        urlObj,
+        url,
         { headers },
         (response) => {
-          if (response.statusCode === 301 || response.statusCode === 302) {
+          if (response.statusCode === 302 || response.statusCode === 301) {
             if (response.headers.location) {
               this.modelUrl = response.headers.location;
               return this._downloadModel().then(resolve).catch(reject);
@@ -640,7 +922,7 @@ var LocalAXIRCompiler = class {
           }
           if (response.statusCode !== 200 && response.statusCode !== 206) {
             return reject(
-              new Error(`Model download failed: HTTP ${response.statusCode}`)
+              new Error(`Download failed: HTTP ${response.statusCode}`)
             );
           }
           const total = parseInt(
@@ -674,76 +956,69 @@ var LocalAXIRCompiler = class {
       });
     });
   }
-  // -------------------------------------------------------------------------
-  // Inference
-  // -------------------------------------------------------------------------
   async _complete(prompt, maxTokens, temperature) {
     if (!this.context) throw new Error("Model not loaded");
     const sequence = this.context.getSequence();
     await sequence.evaluate(prompt);
-    const response = await sequence.generateResponse(maxTokens, {
+    const result = await sequence.generateResponse(maxTokens, {
       temperature,
       grammar: this.grammar
     });
     let text = "";
-    for await (const token of response) {
+    for await (const token of result) {
       text += token;
     }
     return text;
   }
-  // -------------------------------------------------------------------------
-  // Prompt builders
-  // -------------------------------------------------------------------------
   _buildCompilePrompt(domHTML, a11yTree, intent, params) {
     const paramsJson = params ? JSON.stringify(params, null, 2) : "{}";
-    return [
-      `<|system|>`,
-      `You are an expert web-scraping analyst. Your job is to read a simplified DOM and accessibility tree, then output a structured JSON object describing the page layout, interactive elements, and data extraction plan.`,
-      ``,
-      `Output MUST be valid JSON matching this schema:`,
-      `- workflow.nodes: map of node_id -> {element_type, semantic_role, intent, tag, selector_candidates[], parent_id?, children_ids?, aria_label?, aria_role?, text_content?, confidence, reasoning?}`,
-      `- workflow.edges: list of {from_node, to_node, action, condition?, probability}`,
-      `- workflow.entry_points: list of starting node_ids`,
-      `- workflow.exit_points: list of terminal node_ids`,
-      `- workflow.domain: the domain name`,
-      `- workflow.page_type: one of landing|search|listing|detail|form|checkout|dashboard|unknown`,
-      `- intents: list of {intent, action, parameters[], context}`,
-      `- selectors: map of selector_name -> list of {type, value, priority}`,
-      `- fields: list of {name, selector, transform?, required}`,
-      `- container?: string (optional container selector name)`,
-      ``,
-      `Element types: button, link, input, form, navigation, search, filter, sort, pagination, container, list, item, heading, text, image, unknown.`,
-      `Selector types: css, semantic, text, attribute.`,
-      `<|user|>`,
-      `Intent: ${intent}`,
-      `Parameters: ${paramsJson}`,
-      ``,
-      `Simplified DOM:`,
-      `${this._truncate(domHTML, 4e4)}`,
-      ``,
-      `Accessibility Tree:`,
-      `${this._truncate(a11yTree, 8e3)}`,
-      ``,
-      `Compile AXIR:`,
-      `<|assistant|>`
-    ].join("\n");
+    const a11y = a11yTree || "No accessibility tree available.";
+    return `|<|system|>
+You are an expert web-scraping analyst. Your job is to read a simplified DOM and accessibility tree, then output a structured JSON object describing the page layout, interactive elements, and data extraction plan.
+
+Output MUST be valid JSON matching this schema:
+- workflow.nodes: map of node_id -> {element_type, semantic_role, intent, tag, selector_candidates[], parent_id?, children_ids?, aria_label?, aria_role?, text_content?, confidence, reasoning?}
+- workflow.edges: list of {from_node, to_node, action, condition?, probability}
+- workflow.entry_points: list of starting node_ids
+- workflow.exit_points: list of terminal node_ids
+- workflow.domain: the domain name
+- workflow.page_type: one of landing|search|listing|detail|form|checkout|dashboard|unknown
+- intents: list of {intent, action, parameters[], context}
+- selectors: map of selector_name -> list of {type, value, priority}
+- fields: list of {name, selector, transform?, required}
+- container?: string (optional container selector name)
+
+Element types: button, link, input, form, navigation, search, filter, sort, pagination, container, list, item, heading, text, image, unknown.
+Selector types: css, semantic, text, attribute.
+|<|user|>
+Intent: ${intent}
+Parameters: ${paramsJson}
+
+Simplified DOM:
+${this._truncate(domHTML, 4e4)}
+
+Accessibility Tree:
+${this._truncate(a11y, 8e3)}
+
+Compile AXIR:
+|<|assistant|>
+`;
   }
   _buildHealPrompt(domHTML, brokenSelector, semanticIntent) {
-    return [
-      `<|system|>`,
-      `You are a CSS selector repair tool. Given a broken selector and the current DOM, output the new CSS selector that targets the same semantic element.`,
-      ``,
-      `Output JSON: {"selector": "...", "confidence": 0.0-1.0, "reasoning": "..."}`,
-      `<|user|>`,
-      `Broken selector: ${brokenSelector}`,
-      `Semantic intent: ${semanticIntent}`,
-      ``,
-      `Current DOM (truncated):`,
-      `${this._truncate(domHTML, 2e4)}`,
-      ``,
-      `New selector:`,
-      `<|assistant|>`
-    ].join("\n");
+    return `|<|system|>
+You are a CSS selector repair tool. Given a broken selector and the current DOM, output the new CSS selector that targets the same semantic element.
+
+Output JSON: {"selector": "...", "confidence": 0.0-1.0, "reasoning": "..."}
+|<|user|>
+Broken selector: ${brokenSelector}
+Semantic intent: ${semanticIntent}
+
+Current DOM (truncated):
+${this._truncate(domHTML, 2e4)}
+
+New selector:
+|<|assistant|>
+`;
   }
   _truncate(text, maxChars) {
     if (text.length <= maxChars) return text;
@@ -759,7 +1034,7 @@ var LocalAXIRCompiler = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AWIClient,
-  AWIError,
+  AXIRCompiler,
   AdvisoryExecutor,
   LocalAXIRCompiler
 });