testronaut 1.2.4 → 1.3.0

package/tests/toolsTests/domControl.test.js

@@ -0,0 +1,329 @@
+// tests/toolsTests/domControl.test.js
+/**
+ * domControl.test.js
+ * -------------------
+ * Purpose:
+ *   Unit tests for DOM normalization helpers in domControl.js.
+ *   Ensures we preserve semantic structure/text while stripping noise
+ *   and collapsing long/repetitive content.
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as cheerio from 'cheerio';
+
+import {
+  removeNonContentTags,
+  collapseLongContent,
+  chunkBySection,
+  reduceRepeatedDivs,
+  removeObfuscatedClassNames,
+  removeAutoGeneratedClasses,
+  minifyDomWhitespace,
+} from '../../tools/domControl.js'; // ← adjust path as needed
+
+describe('domControl helpers', () => {
+  describe('removeNonContentTags', () => {
+    it('removes non-content tags and non-whitelisted attributes', async () => {
+      const html = `
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <script>console.log('hi');</script>
+            <style>.foo { color: red; }</style>
+            <link rel="stylesheet" href="style.css" />
+          </head>
+          <body data-theme="dark">
+            <!-- comment -->
+            <div id="main" data-testid="main" onclick="alert('x')">
+              <iframe src="frame.html"></iframe>
+              <canvas></canvas>
+              <svg></svg>
+              <a href="/home" rel="noopener" target="_blank">Home</a>
+              <input id="email" name="email" type="email" data-tracking="abc" />
+            </div>
+          </body>
+        </html>
+      `;
+      const $ = cheerio.load(html);
+
+      await removeNonContentTags($);
+      const result = $.html();
+
+      // Non-content tags removed
+      expect(result).not.toContain('<script');
+      expect(result).not.toContain('<style');
+      expect(result).not.toContain('<meta');
+      expect(result).not.toContain('<link');
+      expect(result).not.toContain('<iframe');
+      expect(result).not.toContain('<canvas');
+      expect(result).not.toContain('<svg');
+      expect(result).not.toContain('<!-- comment -->');
+
+      // Body-level non-whitelisted attribute stripped
+      expect($('body').attr('data-theme')).toBeUndefined();
+
+      // Whitelisted attrs preserved
+      const main = $('#main');
+      expect(main.attr('id')).toBe('main');
+      expect(main.attr('data-testid')).toBeUndefined();
+      expect(main.attr('onclick')).toBeUndefined();
+
+      const input = $('#email');
+      expect(input.attr('id')).toBe('email');
+      expect(input.attr('name')).toBe('email');
+      expect(input.attr('type')).toBe('email');
+      expect(input.attr('data-tracking')).toBeUndefined();
+
+      const link = $('a[href="/home"]');
+      expect(link.attr('href')).toBe('/home');
+      // rel/target should be stripped (not whitelisted)
+      expect(link.attr('rel')).toBeUndefined();
+      expect(link.attr('target')).toBeUndefined();
+    });
+  });
+
+  describe('collapseLongContent', () => {
+    it('collapses long lists and appends a truncated marker', async () => {
+      const html = `
+        <ul id="list">
+          <li>Item 1</li>
+          <li>Item 2</li>
+          <li>Item 3</li>
+          <li>Item 4</li>
+        </ul>
+        <div id="cards">
+          <div class="card">A</div>
+          <div class="card">B</div>
+          <div class="card">C</div>
+          <div class="card">D</div>
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      await collapseLongContent($, 2);
+
+      const listItems = $('#list').children('li');
+      expect(listItems.length).toBe(3); // 2 kept + 1 truncated
+      expect(listItems.eq(0).text()).toBe('Item 1');
+      expect(listItems.eq(1).text()).toBe('Item 2');
+      expect(listItems.eq(2).attr('data-collapsed')).toBe('true');
+
+      const cardChildren = $('#cards').children();
+      expect(cardChildren.length).toBe(3); // 2 cards + truncated div
+      expect(cardChildren.eq(0).hasClass('card')).toBe(true);
+      expect(cardChildren.eq(1).hasClass('card')).toBe(true);
+      expect(cardChildren.eq(2).attr('data-collapsed')).toBe('true');
+    });
+  });
+
+  describe('chunkBySection', () => {
+    it('returns section HTML for header/nav/main/footer/aside/body', async () => {
+      const html = `
+        <html>
+          <body>
+            <header><h1>Title</h1></header>
+            <nav><a href="/a">A</a></nav>
+            <main><p>Content</p></main>
+            <aside><p>Side</p></aside>
+            <footer><p>Foot</p></footer>
+          </body>
+        </html>
+      `;
+      const $ = cheerio.load(html);
+
+      const chunks = await chunkBySection($);
+
+      expect(chunks.header).toContain('Title');
+      expect(chunks.nav).toContain('href="/a"');
+      expect(chunks.main).toContain('Content');
+      expect(chunks.aside).toContain('Side');
+      expect(chunks.footer).toContain('Foot');
+      expect(chunks.body).toContain('<header>');
+    });
+
+    it('honors the focus list and only returns requested keys', async () => {
+      const html = `
+        <body>
+          <header>H</header>
+          <main>M</main>
+          <footer>F</footer>
+        </body>
+      `;
+      const $ = cheerio.load(html);
+
+      const chunks = await chunkBySection($, ['main', 'footer']);
+
+      expect(Object.keys(chunks).sort()).toEqual(['footer', 'main']);
+      expect(chunks.main).toContain('M');
+      expect(chunks.footer).toContain('F');
+    });
+  });
+
+  describe('reduceRepeatedDivs', () => {
+    it('reduces repeated divs by class and appends a collapsed marker', () => {
+      const html = `
+        <div id="root">
+          <div class="card">1</div>
+          <div class="card">2</div>
+          <div class="card">3</div>
+          <div class="card">4</div>
+          <div class="other">X</div>
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      reduceRepeatedDivs($, 2);
+
+      const rootChildren = $('#root').children('div');
+      const cardDivs = $('#root').children('div.card');
+      const collapsedMarkers = $('#root').children('div[data-collapsed="true"]');
+
+      // Only 2 card divs should remain
+      expect(cardDivs.length).toBe(2);
+      expect(cardDivs.eq(0).text()).toBe('1');
+      expect(cardDivs.eq(1).text()).toBe('2');
+
+      // One collapsed marker added for the "card" class
+      expect(collapsedMarkers.length).toBe(1);
+      expect(collapsedMarkers.attr('data-class')).toBe('card');
+
+      // "other" div should still be present
+      const other = $('#root').children('div.other');
+      expect(other.length).toBe(1);
+      expect(other.text().trim()).toBe('X');
+
+      // Total children: 2 cards + 1 other + 1 marker
+      expect(rootChildren.length).toBe(4);
+    });
+  });
+
+  describe('removeObfuscatedClassNames', () => {
+    it('removes short and hashed-looking class names', () => {
+      const html = `
+        <div id="foo" class="btn a abcd12 AbCdE1 custom-class"></div>
+      `;
+      const $ = cheerio.load(html);
+
+      removeObfuscatedClassNames($);
+
+      const classAttr = $('#foo').attr('class') || '';
+      const classes = classAttr.split(/\s+/).filter(Boolean);
+
+      // 'btn' + 'custom-class' should remain, short "a" and hashed ones removed
+      expect(classes).toContain('btn');
+      expect(classes).toContain('custom-class');
+      expect(classes).not.toContain('a');
+      expect(classes).not.toContain('abcd12');
+      expect(classes).not.toContain('AbCdE1');
+    });
+
+    it('removes class attribute entirely if nothing remains', () => {
+      const html = `<div id="bar" class="a abcd12 AbCdE1"></div>`;
+      const $ = cheerio.load(html);
+
+      removeObfuscatedClassNames($);
+
+      expect($('#bar').attr('class')).toBeUndefined();
+    });
+  });
+
+  describe('removeAutoGeneratedClasses', () => {
+    it('removes known utility classes while keeping semantic ones', () => {
+      const html = `
+        <button
+          id="btn"
+          class="text-sm bg-red-500 hover:bg-red-600 flex items-center btn-primary custom-class"
+        >
+          Click
+        </button>
+      `;
+      const $ = cheerio.load(html);
+
+      removeAutoGeneratedClasses($);
+
+      const classAttr = $('#btn').attr('class') || '';
+      const classes = classAttr.split(/\s+/).filter(Boolean);
+
+      // Utility classes should be gone
+      expect(classes).not.toContain('text-sm');
+      expect(classes).not.toContain('bg-red-500');
+      expect(classes).not.toContain('hover:bg-red-600');
+      expect(classes).not.toContain('flex');
+      expect(classes).not.toContain('items-center');
+
+      // Semantic classes should remain
+      expect(classes).toContain('btn-primary');
+      expect(classes).toContain('custom-class');
+    });
+
+    it('removes class attribute entirely if all classes are utilities', () => {
+      const html = `<div id="box" class="flex items-center text-sm"></div>`;
+      const $ = cheerio.load(html);
+
+      removeAutoGeneratedClasses($);
+
+      expect($('#box').attr('class')).toBeUndefined();
+    });
+  });
+
+  describe('minifyDomWhitespace', () => {
+    it('collapses whitespace in text nodes while preserving words', () => {
+      const html = `
+        <div id="content">
+          Hello
+          world,
+          this   is
+          a   test.
+        </div>
+      `;
+      const $ = cheerio.load(html);
+
+      minifyDomWhitespace($);
+
+      const text = $('#content').text();
+      // We only care that internal runs are collapsed and words are separated
+      expect(text).toContain('Hello world, this is a test.');
+      // No stray newlines or multiple spaces
+      expect(/\s{2,}/.test(text)).toBe(false);
+    });
+
+    it('preserves whitespace inside pre/code/textarea', () => {
+      const html = `
+        <pre id="code-block">
+          line 1
+              line 2    with   spaces
+        </pre>
+        <textarea id="ta">
+line A
+    line B
+        </textarea>
+      `;
+      const $ = cheerio.load(html);
+
+      const beforePre = $('#code-block').text();
+      const beforeTa = $('#ta').text();
+
+      minifyDomWhitespace($);
+
+      const afterPre = $('#code-block').text();
+      const afterTa = $('#ta').text();
+
+      expect(afterPre).toBe(beforePre);
+      expect(afterTa).toBe(beforeTa);
+    });
+
+    it('keeps at least one space for pure-whitespace text nodes', () => {
+      const html = `<p>Foo <span>bar</span> baz</p>`;
+      const $ = cheerio.load(html);
+
+      minifyDomWhitespace($);
+
+      const text = $('p').text();
+      // We don’t want "Foobarbaz"
+      expect(text.includes('Foo')).toBe(true);
+      expect(text.includes('bar')).toBe(true);
+      expect(text.includes('baz')).toBe(true);
+      expect(text).toMatch(/Foo.*bar.*baz/);
+    });
+  });
+});

package/tools/chromeBrowser.js

@@ -17,6 +17,7 @@ import {
   removeAutoGeneratedClasses, 
   removeNonContentTags,
   removeObfuscatedClassNames, 
+  minifyDomWhitespace
 } from './domControl.js';
 import fs from 'fs';
 import path from 'path';
@@ -870,6 +871,9 @@ export class ChromeBrowser {
       // $ = await removeAutoGeneratedClasses($);
     }
 
+    // Minify whitespace *after* structural cleanup
+    $ = minifyDomWhitespace($);
+
     // (Optional: If you'd like to use `focus`, you could filter here by selectors/keywords.)
 
     // --- 5) Return trimmed HTML ---

package/tools/contextControl.js

@@ -0,0 +1,307 @@
+// Tools whose *content* tends to be extremely large (DOM, etc.).
+// We keep their existence in context, but can safely stub older payloads.
+const HEAVY_SEMANTIC_TOOLS = new Set([
+  'get_dom',
+]);
+
+/**
+ * Safely prune/sanitize older heavy tool messages in the conversation.
+ *
+ * Goals:
+ *   - Keep recent DOM snapshots intact (last few).
+ *   - For older ones, keep the tool message but replace content with a stub.
+ *
+ * This preserves conversational structure while shrinking token load.
+ *
+ * @param {Array} messages - conversation history (mutated in-place).
+ * @param {object} opts
+ * @param {number} opts.keepRecentPerTool - how many latest tool results to keep verbatim
+ */
+export function sanitizeHeavyToolHistory(messages, { keepRecentPerTool = 2 } = {}) {
+  // Track latest indices per tool name
+  const indicesByTool = new Map();
+
+  messages.forEach((m, idx) => {
+    if (m.role === 'tool' && m.name && HEAVY_SEMANTIC_TOOLS.has(m.name)) {
+      if (!indicesByTool.has(m.name)) indicesByTool.set(m.name, []);
+      indicesByTool.get(m.name).push(idx);
+    }
+  });
+
+  // For each tool, stub all but the last `keepRecentPerTool`
+  for (const [toolName, indices] of indicesByTool.entries()) {
+    const toStub = indices.slice(0, Math.max(0, indices.length - keepRecentPerTool));
+    for (const i of toStub) {
+      const msg = messages[i];
+      msg.content = `[${toolName} output omitted for brevity – older snapshot]`;
+    }
+  }
+}
+
+
+/**
+ * Prune overall conversation context to keep it within a bounded window.
+ *
+ * Strategy:
+ *   - Always keep all system messages.
+ *   - Start from the end and keep the last `maxNonSystemMessages` non-system messages.
+ *   - Ensure protocol correctness:
+ *       * If a tool message is kept, its parent assistant with matching tool_call_id
+ *         must also be present in the kept window. Otherwise, drop that tool message.
+ *
+ * This avoids "tool message without preceding tool_calls" API errors.
+ *
+ * @param {Array} messages - conversation history
+ * @param {object} opts
+ * @param {number} opts.maxNonSystemMessages
+ * @returns {Array} pruned messages (new array)
+ */
+export function pruneConversationContext(messages, { maxNonSystemMessages = 40 } = {}) {
+  const systemMessages = messages.filter(m => m.role === 'system');
+  const nonSystem = messages.filter(m => m.role !== 'system');
+
+  // Take last N non-system messages (raw window)
+  const tail = nonSystem.slice(-maxNonSystemMessages);
+
+  // Pass 1: build map of tool_call_id -> index of assistant in tail
+  const assistantToolParents = new Map(); // tool_call_id -> index in tail
+  tail.forEach((m, idx) => {
+    if (m.role === 'assistant' && Array.isArray(m.tool_calls)) {
+      for (const tc of m.tool_calls) {
+        if (tc && tc.id) {
+          assistantToolParents.set(tc.id, idx);
+        }
+      }
+    }
+  });
+
+  // Pass 2: filter out tool messages that have no parent assistant in the tail
+  const cleanedTail = [];
+  for (const m of tail) {
+    if (m.role === 'tool') {
+      const toolId = m.tool_call_id;
+      if (!toolId) {
+        // Defensive: if there's no tool_call_id at all, drop it.
+        continue;
+      }
+      if (!assistantToolParents.has(toolId)) {
+        // Parent assistant with this tool_call_id not present in tail,
+        // so keeping this tool message would violate the protocol. Drop it.
+        continue;
+      }
+    }
+    cleanedTail.push(m);
+  }
+
+  return [...systemMessages, ...cleanedTail];
+}
+
+/* ---------------- Ground Control state helpers ----------------
+ * These helpers back the "set_ground_control_state" and "record_mission_telemetry"
+ * tools. They are designed to:
+ *   - Keep durable mission facts (URL, login state, constraints) outside
+ *     the pruned chat window.
+ *   - Accumulate a lightweight telemetry trail (breadcrumbs, assertions,
+ *     issues, and notes) that can be surfaced in reports.
+ */
+
+/**
+ * Create a normalized, empty Ground Control state object.
+ * Safe to reuse per mission and to serialize into reports.
+ *
+ * @returns {object} groundControl
+ */
+export function createEmptyGroundControl() {
+  return {
+    app: {
+      baseUrl: null,
+      currentUrl: null,
+      routeRole: null,      // e.g. "login", "chat", "dashboard"
+    },
+    session: {
+      loggedIn: null,       // true/false/null (unknown)
+      userLabel: null,      // "Demo user", "Shane Fast", etc.
+      tenant: null,         // workspace / tenant label if applicable
+    },
+    navigation: {
+      currentLabel: null,   // human label for where we are, e.g. "Main chat page"
+    },
+    constraints: {
+      stayWithinBaseUrl: null, // if true, avoid leaving app.baseUrl unless told to
+    },
+    telemetry: [],             // array of { kind, text, status, ts, turn? }
+  };
+}
+
+/**
+ * Apply a partial update from the `set_ground_control_state` tool to the
+ * existing Ground Control state.
+ *
+ * - Mutates the provided `groundControl` in-place for simplicity.
+ * - Only merges known sections/keys; unknown keys are ignored defensively.
+ *
+ * @param {object} groundControl - existing state (will be mutated)
+ * @param {object} payload - tool arguments from set_ground_control_state
+ * @returns {object} the same groundControl reference (for chaining)
+ */
+export function applyGroundControlUpdate(groundControl, payload = {}) {
+  if (!groundControl) {
+    throw new Error('applyGroundControlUpdate called without an existing groundControl state');
+  }
+
+  // 🔐 Ensure sub-objects exist so we can safely assign into them
+  groundControl.app = groundControl.app || {};
+  groundControl.session = groundControl.session || {};
+  groundControl.navigation = groundControl.navigation || {};
+  groundControl.constraints = groundControl.constraints || {};
+
+  const { app, session, navigation, constraints } = payload;
+
+  if (app && typeof app === 'object') {
+    groundControl.app.baseUrl = app.baseUrl ?? groundControl.app.baseUrl;
+    groundControl.app.currentUrl = app.currentUrl ?? groundControl.app.currentUrl;
+    groundControl.app.routeRole = app.routeRole ?? groundControl.app.routeRole;
+  }
+
+  if (session && typeof session === 'object') {
+    if (typeof session.loggedIn === 'boolean' || session.loggedIn === null) {
+      groundControl.session.loggedIn = session.loggedIn;
+    }
+    if (typeof session.userLabel === 'string') {
+      groundControl.session.userLabel = session.userLabel;
+    }
+    if (typeof session.tenant === 'string') {
+      groundControl.session.tenant = session.tenant;
+    }
+  }
+
+  if (navigation && typeof navigation === 'object') {
+    if (typeof navigation.currentLabel === 'string') {
+      groundControl.navigation.currentLabel = navigation.currentLabel;
+    }
+  }
+
+  if (constraints && typeof constraints === 'object') {
+    if (typeof constraints.stayWithinBaseUrl === 'boolean' || constraints.stayWithinBaseUrl === null) {
+      groundControl.constraints.stayWithinBaseUrl = constraints.stayWithinBaseUrl;
+    }
+  }
+
+  return groundControl;
+}
+
+/**
+ * Append a telemetry entry to Ground Control from the `record_mission_telemetry` tool.
+ *
+ * Each entry is small and durable, and can be surfaced in final mission reports.
+ *
+ * @param {object} groundControl - existing state (mutated in-place)
+ * @param {object} entry - { kind, text, status? } from tool args
+ * @param {object} meta - optional metadata (e.g., { turn })
+ * @returns {object} the appended telemetry object
+ */
+export function recordGroundTelemetry(groundControl, entry, meta = {}) {
+  if (!groundControl) {
+    throw new Error('recordGroundTelemetry called without an existing groundControl state');
+  }
+
+  if (!groundControl.telemetry) {
+    groundControl.telemetry = [];
+  }
+
+  const { kind, text, status } = entry || {};
+  if (!kind || !text) {
+    // Defensive: only record well-formed entries
+    return null;
+  }
+
+  const telemetry = {
+    kind,                         // 'breadcrumb' | 'assertion' | 'issue' | 'note'
+    text,
+    status: status || 'n/a',      // 'passed' | 'failed' | 'n/a'
+    ts: new Date().toISOString(),
+    ...meta,                      // e.g., { turn: 3 }
+  };
+
+  groundControl.telemetry.push(telemetry);
+  return telemetry;
+}
+
+/**
+ * Build a compact, model-friendly snapshot of Ground Control for use in prompts.
+ *
+ * Goals:
+ *   - Keep *critical* durable facts (URL, login state, rough route/area)
+ *     available between missions without dragging the full state into context.
+ *   - Emit a very small object that can be safely JSON.stringified and injected
+ *     into a system message or "Ground Control" note.
+ *   - Return `null` when there is no meaningful signal yet, so callers can skip
+ *     adding noise to the prompt.
+ *
+ * Shape of the snapshot:
+ *   {
+ *     app: {
+ *       baseUrl: string | null,
+ *       currentUrl: string | null,
+ *     },
+ *     session: {
+ *       loggedIn: boolean,        // coerced with `!!` (null/undefined → false)
+ *       userLabel: string | null,
+ *     },
+ *     navigation: {
+ *       routeRole: string | null, // high-level role like "login", "chat", etc.
+ *       currentLabel: string | null, // human label like "Main chat page"
+ *     },
+ *     telemetryLines: string[]    // up to 5 last telemetry entries, pre-formatted
+ *   }
+ *
+ * @param {object} gc - Full Ground Control state as maintained by the tools.
+ * @returns {object|null} A compact snapshot or `null` if there is no signal.
+ */
+export function summarizeGroundControlForPrompt(gc = {}) {
+  if (!gc || typeof gc !== 'object') return null;
+
+  const app = gc.app || {};
+  const session = gc.session || {};
+  const navigation = gc.navigation || {};
+  const telemetry = Array.isArray(gc.telemetry) ? gc.telemetry : [];
+
+  const routeRole = typeof navigation.routeRole === 'string'
+    ? navigation.routeRole
+    : (typeof app.routeRole === 'string' ? app.routeRole : null);
+  const currentLabel = typeof navigation.currentLabel === 'string' ? navigation.currentLabel : null;
+
+  // Only emit snapshot if we have at least *some* meaningful info
+  const hasSignal =
+    app.baseUrl ||
+    app.currentUrl ||
+    typeof session.loggedIn === 'boolean' ||
+    routeRole ||
+    currentLabel ||
+    telemetry.length > 0;
+
+  if (!hasSignal) return null;
+
+  const telemetryLines = telemetry
+    .slice(-5) // last 5 breadcrumbs max
+    .map(t => {
+        const statusSuffix = t.status && t.status !== 'n/a' ? ` (${t.status})` : '';
+        return `- [${t.kind}]${statusSuffix} ${t.text}`;
+    });
+
+  return {
+    app: {
+      baseUrl: app.baseUrl || null,
+      currentUrl: app.currentUrl || null,
+    },
+    session: {
+      loggedIn: !!session.loggedIn,
+      userLabel: session.userLabel || null,
+    },
+    navigation: {
+      routeRole,
+      currentLabel,
+    },
+    telemetryLines,
+  };
+}