@enricai/barnacle 1.0.0

package/dist/scripts/recon-browser.d.ts

@@ -0,0 +1,304 @@
+/**
+ * Phase 1 recon: drives a real browser through a user-defined flow while
+ * wiretapping every network response. Captures are written to
+ * /tmp/recon/graphql/<NNN>-<phase>-<operationName>.json — one file per call,
+ * diffable and greppable.
+ *
+ * Recovery model — each flow step runs through a 4-attempt self-healing cascade
+ * (act → observe+act → observe+act with ignoreSelectors → Anthropic-SDK rephrase),
+ * verified by "did the network counter advance OR did the URL change". On terminal
+ * cascade failure the step is dumped to /tmp/recon/step-failures/ and the script's
+ * main() loop attempts up to MAX_REPLANS=2 global replans, where Claude rewrites
+ * the remaining flow tail given the failure context. Bedrock-only deployments
+ * skip the LLM-rephrase attempt and the replan loop with a startup warn. See
+ * docs/playbook.md sections 1c–1e for the full design.
+ *
+ * Usage:
+ *   pnpm tsx src/scripts/recon-browser.ts \
+ *     --url https://example.com \
+ *     --flow '["click the category filter", "open the first product"]'
+ *
+ *   # Or load the flow from a committed file (preferred — makes recon re-runnable):
+ *   pnpm tsx src/scripts/recon-browser.ts \
+ *     --url https://example.com \
+ *     --flow-file src/sites/my-site/recon-flow.json
+ *
+ *   # Captures every network response — no URL-shape filtering. Use grep
+ *   # against /tmp/recon/graphql/ if you only want specific endpoints.
+ *   pnpm tsx src/scripts/recon-browser.ts --url https://example.com
+ *
+ * The script needs STEEL_API_KEY and either ANTHROPIC_API_KEY or USE_BEDROCK=true
+ * in the environment (same vars as the main server).
+ *
+ * Runtime: varies — ~20–40 min for a full flow (STEP_PAUSE_MS × N steps + LLM latency
+ * per act; healing and replans push the upper bound higher on flaky sites).
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { Page, Stagehand } from "@browserbasehq/stagehand";
+import { type AttemptRecord, type CaptureFn } from "../scraper/flow-runner";
+import type { Logger } from "../types/logging";
+interface ReplanEvent {
+    replanIndex: number;
+    cause: "probe-absent" | "cascade-exhausted";
+    indexAtFailure: number;
+    failedInstruction: string;
+    replanSteps: NormalizedStep[];
+    timestamp: string;
+    /**
+     * Page state at the moment this replan was constructed. Used by
+     * isReplanCycle to distinguish "same proposal under static page" (true
+     * cycle) from "same proposal but page state advanced" (legitimate retry
+     * under new conditions). Cheap signals: url equality + a permissive
+     * htmlLength delta. See HTML_STATIC_TOLERANCE for the threshold rationale.
+     */
+    pageState: {
+        url: string;
+        htmlLength: number;
+    };
+}
+export declare function detectRejectionInResponseBody(body: unknown): {
+    rejected: boolean;
+    reason: string | null;
+};
+export declare function findWizardRestartSignal(params: {
+    preIdx: number;
+    capturesDir?: string;
+    restartSignalUrlPatterns: readonly string[];
+}): string | null;
+export declare function isStructurallyBlocked(attempts: readonly {
+    triedSelectors: readonly string[];
+    verifiedBy: string | null;
+}[]): boolean;
+export declare function summarizeReplanFailureKinds(params: {
+    callsNdjsonPath: string;
+    callType: string;
+    tailCount?: number;
+}): string;
+/**
+ * Detect a true replan cycle: the same multi-step instruction sequence
+ * proposed REPLAN_CYCLE_THRESHOLD times in a row under page state that
+ * hasn't materially advanced. The page-state guard (URL equality + bounded
+ * htmlLength delta) is essential — a re-proposal under genuinely different
+ * page state is a valid retry, not a cycle. Without the guard we'd block
+ * legitimate "the page advanced; the same step now works" recoveries.
+ */
+export declare function isReplanCycle(priorReplans: readonly ReplanEvent[], newSteps: readonly NormalizedStep[], currentState: {
+    url: string;
+    htmlLength: number;
+}): boolean;
+/**
+ * Internal normalized step shape. Source-flow strings normalize with all flags
+ * false. `origin` distinguishes hand-authored steps from steps the LLM
+ * replanner appended at cascade-exhausted recovery points — persistReplannedFlow
+ * uses it to force replan-origin steps to optional on write-back, preventing
+ * cross-employer regressions when a Presbyterian-specific replanned question
+ * gets persisted and the next run is on Encompass.
+ */
+interface NormalizedStep {
+    instruction: string;
+    optional: boolean;
+    upload: boolean;
+    submitStep?: boolean;
+    payloadField?: string;
+    payloadFieldNone?: boolean;
+    origin: "original" | "replan";
+}
+/**
+ * Inverse of normalizeFlow: maps an internal `NormalizedStep` back to the
+ * on-disk union shape. Bare string for the common case (required,
+ * non-upload); object with only the truthy flags otherwise. Round-trip is
+ * lossless against `RECON_FLOW_SCHEMA` for any value the parser accepted.
+ */
+declare function denormalizeStep(step: NormalizedStep): string | {
+    step: string;
+    optional?: true;
+    upload?: true;
+    submitStep?: true;
+    payloadField?: string;
+    payloadFieldNone?: true;
+};
+/**
+ * Collapse any consecutive run of structurally-identical denormalized
+ * steps into a single entry. Used by `persistReplannedFlow` before write-
+ * back so cumulative-replan noise (each cascade-exhausted replan adds the
+ * same recovery bridge to the tail; after 5 replans the persisted file
+ * carries 5 stacked copies) doesn't pollute the on-disk flow.
+ *
+ * Comparison is structural via JSON-stringify equality:
+ * - Two strings with the same value collapse.
+ * - Two objects with the same {step, optional, upload} collapse.
+ * - A string and an object with the same instruction do NOT collapse — they
+ *   are semantically different (bare = required, object = could be optional
+ *   or upload).
+ *
+ * Only CONSECUTIVE duplicates collapse. A non-adjacent repeat is preserved
+ * since flow authors sometimes intentionally re-fill a field after a
+ * downstream interaction (e.g. re-fill First Name after the resume upload
+ * triggers an Angular re-render). Adjacent duplicates are almost always
+ * accumulation noise from successive replans converging on the same idea.
+ */
+declare function dedupeConsecutiveIdentical<T>(items: T[]): T[];
+/**
+ * Resume-from-failure filter for replan output. The global replanner should emit
+ * only a recovery BRIDGE from the failure point (the original remaining tail is
+ * re-appended by the driver), but it sometimes re-emits already-completed steps
+ * — re-filling name/email/etc. after a later step fails — which inflates the
+ * plan and wastes wall-clock + replan budget re-doing done work. Drop any bridge
+ * step whose instruction matches a completed step, EXCEPT a re-emission of the
+ * failed step itself (a legitimate no-op bridge the replan prompt allows).
+ */
+export declare function filterCompletedFromReplan(newSteps: readonly NormalizedStep[], completedSteps: readonly string[], failedStep: string): NormalizedStep[];
+/**
+ * Detect a replan that only re-proposes the step that JUST terminally failed —
+ * i.e. after {@link filterCompletedFromReplan} the sole surviving bridge step is
+ * byte-identical (whitespace/case-normalized) to the failed instruction. The
+ * replan prompt allows a no-op re-emission of the failed step, but a bridge that
+ * is NOTHING but the failed step is a guaranteed re-fail: resuming re-runs the
+ * whole 5-attempt cascade on the exact click that just exhausted it (~1m40s
+ * wasted) before the cycle detector — which needs REPLAN_CYCLE_THRESHOLD repeats
+ * under a static page — even engages. This catches it on the FIRST occurrence.
+ * Pure; returns false whenever the bridge adds any genuinely new step.
+ */
+export declare function isReplanReproposingFailedStep(newSteps: readonly NormalizedStep[], failedStep: string): boolean;
+/**
+ * Write-back at the end of a successful recon: back up the original file
+ * bytes verbatim (so a subtle denormalization bug can never lose the user's
+ * hand-authored flow), then write the in-memory plan back out and log a
+ * summary of each replan event. No-op when `--no-save-replan` was passed or
+ * when no replans fired.
+ *
+ * Backup path encodes the timestamp + .bak so accumulated backups are easy
+ * to sort and prune. Uses synchronous writes — the recon is single-purpose
+ * and we want the failure mode "write the bytes, then exit" rather than
+ * "exit with the write half-flushed."
+ */
+declare function persistReplannedFlow(params: {
+    flowFile: string;
+    finalPlan: NormalizedStep[];
+    replanEvents: ReplanEvent[];
+    logger: Logger;
+    /**
+     * Preserves the user's on-disk shape — bare array stays bare array,
+     * object form stays object form. Defaults to "array" for back-compat with
+     * older callers (tests, internal scripts) that don't know about the
+     * object form yet.
+     */
+    originalShape?: "array" | "object";
+    /** Carried through when the original file declared a submit pattern. */
+    submitEndpointPattern?: string | null;
+    /** Carried through when the original file declared submitted-state DOM selectors. */
+    submittedStateSelectors?: string[];
+    /** Carried through when the original file opted into network-authoritative verification. */
+    requireSubmitEndpointMatch?: boolean;
+    /** Carried through when the original file declared success-URL fragments for the Haiku verifier. */
+    successUrlFragments?: string[];
+    /** Carried through when the original file declared success-page-title hints for the Haiku verifier. */
+    successPageTitleHints?: string[];
+    /** Carried through when the original file declared own-backend hostnames for the Haiku verifier. */
+    ownBackendHostnames?: string[];
+    /** Carried through when the original file declared known error-class prefixes for the Haiku judges. */
+    knownErrorClassPrefixes?: string[];
+}): void;
+export declare function renderStepWindow(steps: readonly string[], options?: {
+    head?: number;
+    tail?: number;
+}): string;
+/**
+ * Detect a "false-premise loop" — the current cascade-exhausted step
+ * shares a slug-prefix with at least N prior replans' failed steps,
+ * suggesting the flow's element model for THIS widget family doesn't
+ * match the actual DOM. Slug derivation mirrors the `currentPhase`
+ * pattern at recon-browser.ts:5001 (24-char alphanumeric prefix of
+ * normalized instruction). When the threshold is exceeded, callers
+ * inject an ELEMENT MODEL CHECK section into the replan prompt so the
+ * LLM is nudged to reconsider whether the failed-step's element
+ * description matches anything on the page.
+ *
+ * Research grounding: Reflexion (Shinn et al., 2023) demonstrates +22%
+ * improvement on AlfWorld via verbal-reinforcement feedback on prior
+ * failures. Our existing replan prompt's PRIOR REPLAN HISTORY section
+ * is Reflexion-style; this helper adds a quantified meta-signal when
+ * the same element pattern fails N+ times in a row.
+ */
+export declare function countSlugPrefixMatches(currentFailedStep: string, priorReplans: readonly ReplanEvent[]): number;
+declare function readFailureDumpEvidence(failureDumpPath: string, options?: {
+    client?: Anthropic | null;
+    knownErrorClassPrefixes?: readonly string[];
+    captureFn?: CaptureFn;
+    /**
+     * Live page from the running session. When provided, the deterministic
+     * `:has()`-based leaf probe runs against the LIVE DOM (authoritative)
+     * before falling back to the dump-based Haiku judge. Optional because
+     * tests inject a dump path without a Playwright session; production
+     * callers (replanRemainingFlow) always have `page` in scope and pass it.
+     */
+    page?: Page;
+}): Promise<{
+    bodyExcerpt: string;
+    unfocusedList: string;
+    invalidFieldList: string;
+    errorTextList: string;
+    recentFailureReasons: string[];
+}>;
+/**
+ * Global fallback after a step terminally fails all healing attempts: rewrites
+ * only the un-run tail of the flow so already-verified steps are not disturbed.
+ * Exported so tests can inject a fake capture sink without a live browser.
+ */
+declare function replanRemainingFlow(params: {
+    client: Anthropic;
+    originalFlow: string[];
+    completedSteps: string[];
+    failedStep: string;
+    remainingSteps: string[];
+    failureDumpPath: string;
+    page: Page;
+    stagehand: Stagehand;
+    captureFn?: CaptureFn;
+    /**
+     * Files in `CAPTURES_DIR` recorded during the failed step's attempt
+     * window. Used to surface structured server-side validation errors
+     * to the replan LLM when a submit actually fired but was rejected.
+     */
+    recentCaptures?: readonly string[];
+    /**
+     * Hostnames considered "the site's own backend" — passed through to
+     * extractSubmitFailureEvidence to filter which 4xx captures count as
+     * form-rejection evidence vs third-party CDN/analytics noise. Replaces
+     * the prior compiled submit-endpoint regex with deterministic hostname
+     * equality on a structured URL component.
+     */
+    ownBackendHostnames?: readonly string[];
+    /**
+     * Site-supplied class-name prefixes that wrap error/invalid state markers.
+     * Threaded into the readFailureDumpEvidence judge calls so the Haiku
+     * invalid-fields and error-messages judges get site-specific hints.
+     */
+    knownErrorClassPrefixes?: readonly string[];
+    /**
+     * Optional short tail of prior steps' verification signals (network,
+     * url, dom, submitted-state-dom). When provided, the prompt gets a
+     * PRIOR STEP TRAJECTORY section so the LLM can distinguish "page has
+     * been visibly transitioning (URL changes / submitted-state markers)"
+     * from "page has been static (network signals + DOM-only updates)".
+     * Helps the replanner avoid proposing regression steps when the form
+     * has already advanced.
+     */
+    trajectory?: readonly {
+        stepIndex: number;
+        verifiedBy: AttemptRecord["verifiedBy"];
+    }[];
+    /**
+     * Previous replans constructed for this run. Rendered into a PRIOR REPLAN
+     * HISTORY section as graduated discouragement — re-proposing a sequence
+     * that already failed is unlikely to converge, but is not forbidden because
+     * intervening cascade steps may have advanced the page since the prior
+     * attempt. The deterministic isReplanCycle predicate is the safety net.
+     */
+    priorReplans?: readonly ReplanEvent[];
+}): Promise<NormalizedStep[] | null>;
+export type { Html5DateFillResult, InvalidFormControl, LeafInvalidField, RadioGroupCandidate, ValidationRejectionPair, VerifyFillReadbackResult, } from "../scraper/flow-runner";
+export { buildRadioIdXPath, capturesAfterIndex, chooseRequiredSelectOption, describeAttemptEffectSignals, extractGaEventEvidence, extractSubmitFailureEvidence, fillHtml5DateTimeInput, findRecentBackendError, findRecentPageTransition, formatValidationRejectedReason, hasBillingErrorBeenLogged, isAdvanceStalled, isAdvanceStep, isDomOnlyAdvanceVerified, isSubmitRevealedInvalid, isUploadAffordanceLabel, isWizardExitAction, latestCaptureIndex, logBillingErrorIfPresent, narrowInvalidFormControl, normalizeDateValue, pairInvalidWithErrors, parseCaptureIndex, parseRadioStep, parseSelectStep, pollEnumerate, probeLeafInvalidContainers, probeStepBeforeAttempts, renderLeafInvalidFields, renderUnfocusedObserve, rephraseWithLLM, resetBillingErrorFlagForTests, selectBodyExcerpt, selectRadioGroupOption, shouldSkipTechnique, shouldVetoFallbackAdvance, verifyFillReadback, waitForTransitionBody, windowHasAdvanceTransition, windowHasTransitionBody, writeFixtureToTempFile, } from "../scraper/flow-runner";
+export type { NormalizedStep, ReplanEvent };
+export { dedupeConsecutiveIdentical, denormalizeStep, persistReplannedFlow, readFailureDumpEvidence, replanRemainingFlow, };
+//# sourceMappingURL=recon-browser.d.ts.map

package/dist/scripts/recon-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recon-browser.d.ts","sourceRoot":"","sources":["../../src/scripts/recon-browser.ts"],"names":[],"mappings":"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"}