Merge pull request #202 from PredicateSystems/planner_executor_agent_gaps

complete planner-executor parity with tracing coverage

Author: rcholic

.husky/pre-commit

@@ -1,4 +1 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
 npx lint-staged

src/agents/planner-executor/automation-task.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { TaskCategory, normalizeTaskCategory } from './task-category';
+
+export interface AutomationTask {
+  task: string;
+  startUrl?: string;
+  goal?: Record<string, unknown>;
+  category?: TaskCategory | null;
+  domainHints: string[];
+}
+
+const TaskCategorySchema = z.preprocess(value => {
+  if (typeof value === 'string') {
+    return normalizeTaskCategory(value);
+  }
+  return value;
+}, z.nativeEnum(TaskCategory).nullable().optional());
+
+export const AutomationTaskSchema = z.object({
+  task: z.string().min(1),
+  startUrl: z.string().url().optional(),
+  goal: z.record(z.string(), z.unknown()).optional(),
+  category: TaskCategorySchema,
+  domainHints: z.array(z.string()).default([]),
+});

src/agents/planner-executor/boundary-detection.ts

@@ -9,6 +9,8 @@
  * successfully navigated as far as possible without credentials.
  */
 
+import type { SnapshotElement, PredicateSpec } from './plan-models';
+
 /**
  * Configuration for authentication boundary detection.
  */
@@ -226,3 +228,119 @@ export function isCheckoutElement(
 
   return false;
 }
+
+function normalizeIntentText(value: string | undefined | null): string {
+  return (value || '').toLowerCase().replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function extractUrlSignals(url: string): string[] {
+  if (!url) {
+    return [];
+  }
+
+  try {
+    const parsed = new URL(url);
+    const signals = [
+      parsed.pathname,
+      parsed.search,
+      parsed.searchParams.get('q') || '',
+      parsed.searchParams.get('query') || '',
+      parsed.searchParams.get('search') || '',
+      parsed.searchParams.get('keyword') || '',
+      parsed.searchParams.get('keywords') || '',
+      parsed.searchParams.get('term') || '',
+      parsed.searchParams.get('s') || '',
+    ];
+    return signals.map(signal => normalizeIntentText(signal)).filter(Boolean);
+  } catch {
+    return [normalizeIntentText(url)];
+  }
+}
+
+function queryTerms(text: string | undefined | null): string[] {
+  return normalizeIntentText(text)
+    .split(/\s+/)
+    .filter(term => term.length >= 3);
+}
+
+function urlPredicateSignals(verify: PredicateSpec[] | undefined): string[] {
+  if (!Array.isArray(verify)) {
+    return [];
+  }
+
+  const signals: string[] = [];
+  for (const predicate of verify) {
+    if (
+      predicate &&
+      typeof predicate.predicate === 'string' &&
+      (predicate.predicate === 'url_contains' || predicate.predicate === 'url_matches')
+    ) {
+      const firstArg = predicate.args?.[0];
+      if (typeof firstArg === 'string' && firstArg.trim()) {
+        signals.push(normalizeIntentText(firstArg));
+      }
+    }
+  }
+
+  return signals;
+}
+
+export function isSearchLikeTypeAndSubmit(
+  step: { action?: string; intent?: string; input?: string; verify?: PredicateSpec[] },
+  element?: Pick<SnapshotElement, 'role' | 'text' | 'name' | 'ariaLabel'> | null
+): boolean {
+  if ((step.action || '').toUpperCase() !== 'TYPE_AND_SUBMIT') {
+    return false;
+  }
+
+  const cues = [
+    normalizeIntentText(step.intent),
+    normalizeIntentText(step.input),
+    normalizeIntentText(element?.role),
+    normalizeIntentText(element?.text),
+    normalizeIntentText(element?.name),
+    normalizeIntentText(element?.ariaLabel),
+    ...urlPredicateSignals(step.verify),
+  ].filter(Boolean);
+
+  return cues.some(cue =>
+    /\b(search|searchbox|find|lookup|look up|query|keywords?|results?)\b/.test(cue)
+  );
+}
+
+export function isUrlChangeRelevantToIntent(
+  previousUrl: string,
+  nextUrl: string,
+  step: { action?: string; intent?: string; input?: string; verify?: PredicateSpec[] },
+  element?: Pick<SnapshotElement, 'role' | 'text' | 'name' | 'ariaLabel'> | null
+): boolean {
+  const normalizedPrevious = normalizeIntentText(previousUrl).replace(/\/+$/, '');
+  const normalizedNext = normalizeIntentText(nextUrl).replace(/\/+$/, '');
+  if (!normalizedNext || normalizedNext === normalizedPrevious) {
+    return false;
+  }
+
+  const predicateSignals = urlPredicateSignals(step.verify);
+  const nextSignals = extractUrlSignals(nextUrl);
+  if (
+    predicateSignals.length > 0 &&
+    predicateSignals.every(signal => nextSignals.some(nextSignal => nextSignal.includes(signal)))
+  ) {
+    return true;
+  }
+
+  if (!isSearchLikeTypeAndSubmit(step, element)) {
+    return true;
+  }
+
+  const searchTerms = [
+    ...queryTerms(step.input),
+    ...queryTerms(step.intent),
+    'search',
+    'query',
+    'results',
+    'find',
+  ];
+
+  return searchTerms.some(term => nextSignals.some(signal => signal.includes(term)));
+}