halo-agent 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "halo-agent",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "HALO local apply agent — auto-fills job applications using your real Chrome session",
   "main": "index.js",
   "bin": {

package/smartFill.js

@@ -55,6 +55,21 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
 
     case 'type': {
       if (!item.value) return { ok: true, reason: 'skip: empty value' };
+      // If the field is actually a combobox/dropdown (scanAccessibility
+      // tagged it that way), the planner shouldn't have typed — the value
+      // we got is the user's INTENT (e.g. "Straight"), and we need to
+      // pick the closest dropdown option ("Heterosexual"). This is the
+      // case where the planner saw no options[] (because they're
+      // hidden until clicked) and fell back to type. Recover by treating
+      // it as click_option.
+      if (field.role === 'combobox' || field.role === 'listbox') {
+        const result = await openAndPickOption(page, locator, item.value, {
+          config: ctx.config, jobId: ctx.jobId, label: field.label,
+        });
+        if (result.ok) return result;
+        // Fall through to text-fill if no option matched at all
+        // (some Greenhouse comboboxes accept free-text in addition to options).
+      }
       // Typeahead path: open suggestion list, pick first match.
       if (field.isTypeahead) {
         return await typeAndPickSuggestion(page, locator, item.value);
@@ -76,29 +91,9 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
     }
 
     case 'click_option': {
-      // Custom dropdown: click trigger, find option by text, click it.
-      try {
-        await locator.click({ timeout: 2500 });
-        await page.waitForTimeout(300);
-        // Look for an option whose visible text equals the planner's pick.
-        const optionSel = '[role="option"], [role="menuitem"], .select__option, li[class*="option"]';
-        const opts = page.locator(optionSel);
-        const count = await opts.count().catch(() => 0);
-        if (count === 0) return { ok: false, reason: 'dropdown opened but no options' };
-        const texts = await opts.allTextContents().catch(() => []);
-        const v = String(item.value).toLowerCase().trim();
-        let idx = texts.findIndex((t) => t.toLowerCase().trim() === v);
-        if (idx === -1) idx = texts.findIndex((t) => t.toLowerCase().includes(v) || v.includes(t.toLowerCase()));
-        if (idx === -1) {
-          await page.keyboard.press('Escape').catch(() => {});
-          return { ok: false, reason: `option "${item.value}" not in dropdown (have: ${texts.slice(0, 5).join(', ')})` };
-        }
-        await opts.nth(idx).click({ timeout: 2000 });
-        return { ok: true, reason: `clicked option: ${texts[idx]}` };
-      } catch (e) {
-        await page.keyboard.press('Escape').catch(() => {});
-        return { ok: false, reason: `click_option failed: ${e.message}` };
-      }
+      return await openAndPickOption(page, locator, item.value, {
+        config: ctx.config, jobId: ctx.jobId, label: field.label,
+      });
     }
 
     case 'set_checkbox': {
@@ -182,6 +177,122 @@ async function executePlanItem(page, item, fieldByMmid, ctx) {
  * keyboard.type, then native-setter — but with verify-after-write to catch
  * React rejecting our value.
  */
+/**
+ * Open a custom dropdown and pick the closest option matching `value`.
+ * Handles the two architectural pitfalls today's Reddit run exposed:
+ *
+ *   1. Stale option lists. Greenhouse's intl-tel-input mounts a
+ *      <ul role="listbox"> of country dial codes the first time the
+ *      Phone field is touched, and never unmounts it. A naive
+ *      page.locator('[role="option"]') matches those FIRST, so we
+ *      end up trying to click "Afghanistan" when the user wanted
+ *      "Heterosexual." Fix: snapshot the page's option count BEFORE
+ *      opening this dropdown, then only look at options that
+ *      appeared AFTER the click — they belong to OUR dropdown.
+ *
+ *   2. Off-screen / hidden options. allTextContents returns text for
+ *      hidden options too. Filter to visible-only before matching.
+ *
+ * Falls back to LLM synonym matching when local exact/substring
+ * matching fails, so "Straight" still picks "Heterosexual."
+ */
+async function openAndPickOption(page, triggerLocator, value, llmCtx) {
+  try {
+    // Snapshot option-list state BEFORE opening so we can identify
+    // the new options.
+    const optionSel = '[role="option"], [role="menuitem"], .select__option, li[class*="option"]';
+    const beforeCount = await page.locator(optionSel).count().catch(() => 0);
+
+    await triggerLocator.click({ timeout: 2500 });
+    await page.waitForTimeout(350);
+
+    // Newly mounted options live at indexes >= beforeCount. If no new
+    // ones appeared, the dropdown may have rendered options earlier
+    // (already-open select). Fall through to scanning all visible.
+    const allOpts = page.locator(optionSel);
+    const totalCount = await allOpts.count().catch(() => 0);
+    const newCount = totalCount - beforeCount;
+
+    // Collect candidate {text, idx} pairs — prefer new options, but if
+    // none, scan all visible ones.
+    const startIdx = newCount > 0 ? beforeCount : 0;
+    const endIdx = totalCount;
+    const candidates = [];
+    for (let i = startIdx; i < endIdx; i++) {
+      const opt = allOpts.nth(i);
+      const visible = await opt.isVisible({ timeout: 200 }).catch(() => false);
+      if (!visible) continue;
+      const text = (await opt.textContent().catch(() => '') || '').replace(/\s+/g, ' ').trim();
+      if (!text) continue;
+      candidates.push({ idx: i, text });
+    }
+
+    if (candidates.length === 0) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: 'dropdown opened but no visible options found' };
+    }
+
+    // STEP 1: exact match (case-insensitive)
+    const v = String(value).toLowerCase().trim();
+    let pick = candidates.find((c) => c.text.toLowerCase() === v);
+
+    // STEP 2: substring either direction (handles "Asian" → "South Asian")
+    if (!pick) pick = candidates.find((c) => {
+      const t = c.text.toLowerCase();
+      return t.includes(v) || v.includes(t);
+    });
+
+    // STEP 3: token overlap (handles "Hispanic" → "Hispanic or Latino")
+    if (!pick) {
+      const vTokens = v.split(/\s+/).filter((t) => t.length > 2);
+      pick = candidates.find((c) => {
+        const tTokens = c.text.toLowerCase().split(/\s+/);
+        return vTokens.some((vt) => tTokens.some((tt) => tt.includes(vt) || vt.includes(tt)));
+      });
+    }
+
+    if (!pick) {
+      // No local match — try LLM pick if we have context. This is the
+      // "Straight" → "Heterosexual" path when synonyms don't appear in
+      // canonical facts.
+      if (llmCtx && llmCtx.config && llmCtx.jobId && llmCtx.label) {
+        try {
+          const res = await fetch(`${llmCtx.config.apiUrl}/smartfill/field-answer`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${llmCtx.config.token}` },
+            body: JSON.stringify({
+              job_id: llmCtx.jobId,
+              field_label: llmCtx.label,
+              field_type: 'select',
+              options: candidates.map((c) => c.text),
+              previously_answered: [{ label: 'user intent', value: String(value) }],
+            }),
+          });
+          if (res.ok) {
+            const { value: picked } = await res.json();
+            if (picked && picked !== 'SKIP') {
+              const pv = picked.toLowerCase().trim();
+              pick = candidates.find((c) => c.text.toLowerCase() === pv)
+                || candidates.find((c) => c.text.toLowerCase().includes(pv) || pv.includes(c.text.toLowerCase()));
+            }
+          }
+        } catch {}
+      }
+    }
+
+    if (!pick) {
+      await page.keyboard.press('Escape').catch(() => {});
+      return { ok: false, reason: `no option matched "${value}" (had ${candidates.length}: ${candidates.slice(0, 4).map((c) => c.text).join(' / ')}${candidates.length > 4 ? '...' : ''})` };
+    }
+
+    await allOpts.nth(pick.idx).click({ timeout: 2000 });
+    return { ok: true, reason: `clicked option: ${pick.text}` };
+  } catch (e) {
+    await page.keyboard.press('Escape').catch(() => {});
+    return { ok: false, reason: `openAndPickOption failed: ${e.message}` };
+  }
+}
+
 async function reactSafeType(page, locator, value) {
   const v = String(value);
   try {
@@ -325,7 +436,12 @@ async function smartFillPage(page, aep, options) {
       continue;
     }
     const labelShort = (f.label || f.selectorHint || '?').slice(0, 50);
-    const result = await executePlanItem(page, item, fieldByMmid, { resumePath, coverLetterPath });
+    const result = await executePlanItem(page, item, fieldByMmid, {
+      resumePath, coverLetterPath,
+      // Threaded so openAndPickOption can hit /smartfill/field-answer for
+      // synonym matching when local fuzzy fails ("Straight" → "Heterosexual").
+      config, jobId,
+    });
     if (result.ok === 'ask_user') {
       askUserReasons.push(`${labelShort}: ${result.reason}`);
       console.warn(`[smartFill] ASK USER: "${labelShort}" — ${result.reason}`);