explorbot 0.1.32-beta.1 → 0.2.0

package/dist/src/state-manager.js

@@ -1,40 +1,27 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import matter from 'gray-matter';
 import { ActionResult } from './action-result.js';
-import { ConfigParser, outputPath } from './config.js';
-import { ExperienceTracker } from './experience-tracker.js';
 import { detectFocusArea } from './utils/aria.js';
 import { createDebug } from './utils/logger.js';
+import { slugify } from './utils/strings.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:state');
 export class StateManager {
     currentState = null;
     stateHistory = [];
     allVisitedUrls = new Set();
-    knowledgeCache = [];
-    lastKnowledgeScan = null;
     stateChangeListeners = [];
     experienceTracker;
-    knowledgeDir;
+    knowledgeTracker;
     nextStateId = 1;
-    constructor() {
-        this.experienceTracker = new ExperienceTracker();
-        const configParser = ConfigParser.getInstance();
-        const config = configParser.getConfig();
-        const configPath = configParser.getConfigPath();
-        // Resolve knowledge directory relative to the config file location (project root)
-        if (configPath) {
-            const projectRoot = dirname(configPath);
-            this.knowledgeDir = join(projectRoot, config.dirs?.knowledge || 'knowledge');
-        }
-        else {
-            this.knowledgeDir = config.dirs?.knowledge || 'knowledge';
-        }
+    constructor(experienceTracker, knowledgeTracker) {
+        this.experienceTracker = experienceTracker;
+        this.knowledgeTracker = knowledgeTracker;
     }
     getExperienceTracker() {
         return this.experienceTracker;
     }
+    getKnowledgeTracker() {
+        return this.knowledgeTracker;
+    }
     /**
      * Subscribe to state change events
      */
@@ -61,11 +48,6 @@ export class StateManager {
             }
         });
     }
-    /**
-     * Extract state path from full URL
-     * Removes domain, port, protocol
-     * Keeps path, query, and hash: /path/to/page?tab=users#section
-     */
     /**
      * Update current state from ActionResult and record transition if state changed
      */
@@ -141,13 +123,7 @@ export class StateManager {
         if (title) {
             parts.push(`title_${title}`);
         }
-        return parts
-            .join('_')
-            .replace(/[^a-zA-Z0-9_]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .toLowerCase()
-            .substring(0, 200);
+        return slugify(parts.join('_')).substring(0, 200);
     }
     /**
      * Get current state
@@ -226,57 +202,14 @@ export class StateManager {
     getRecentTransitions(count = 5) {
         return this.stateHistory.slice(-count);
     }
-    /**
-     * Scan knowledge directory for .md files and cache them
-     */
-    scanKnowledgeFiles() {
-        const now = new Date();
-        // Only rescan every 30 seconds to avoid excessive file I/O
-        if (this.lastKnowledgeScan && now.getTime() - this.lastKnowledgeScan.getTime() < 30000) {
-            return;
-        }
-        this.knowledgeCache = [];
-        if (!existsSync(this.knowledgeDir)) {
-            debugLog(`Knowledge directory not found: ${this.knowledgeDir}`);
-            return;
-        }
-        try {
-            const files = readdirSync(this.knowledgeDir, { recursive: true })
-                .filter((file) => typeof file === 'string' && file.endsWith('.md'))
-                .map((file) => join(this.knowledgeDir, file));
-            for (const filePath of files) {
-                try {
-                    const fileContent = readFileSync(filePath, 'utf8');
-                    const parsed = matter(fileContent);
-                    const urlPattern = parsed.data.url || parsed.data.path || '*';
-                    this.knowledgeCache.push({
-                        filePath,
-                        url: urlPattern,
-                        ...parsed.data,
-                        content: parsed.content,
-                    });
-                    debugLog(`Loaded knowledge file: ${filePath} (pattern: ${urlPattern})`);
-                }
-                catch (error) {
-                    debugLog(`Failed to load knowledge file ${filePath}:`, error);
-                }
-            }
-            this.lastKnowledgeScan = now;
-            debugLog(`Scanned ${this.knowledgeCache.length} knowledge files`);
-        }
-        catch (error) {
-            debugLog('Failed to scan knowledge directory:', error);
-        }
-    }
     /**
      * Get relevant knowledge files for current state
      */
     getRelevantKnowledge() {
         if (!this.currentState)
             return [];
-        this.scanKnowledgeFiles();
         const actionResult = ActionResult.fromState(this.currentState);
-        return this.knowledgeCache.filter((knowledge) => actionResult.isMatchedBy(knowledge));
+        return this.knowledgeTracker.getRelevantKnowledge(actionResult);
     }
     /**
      * Get relevant experience files for current state
@@ -291,17 +224,6 @@ export class StateManager {
     /**
      * Get all context for current state (knowledge + experience)
      */
-    getCurrentContext() {
-        if (!this.currentState) {
-            throw new Error('No current state available');
-        }
-        return {
-            state: this.currentState,
-            knowledge: this.getRelevantKnowledge(),
-            experience: this.getRelevantExperience(),
-            recentTransitions: this.getRecentTransitions(),
-        };
-    }
     /**
      * Check if we've been in this state before
      */
@@ -333,41 +255,6 @@ export class StateManager {
      * If the last transition changed URL, returns the fromState (for URL change detection).
      * Otherwise returns the most recent toState with content (for diffing).
      */
-    getPreviousState() {
-        if (this.stateHistory.length === 0)
-            return null;
-        const lastTransition = this.stateHistory[this.stateHistory.length - 1];
-        if (lastTransition.fromState?.url !== lastTransition.toState?.url) {
-            return lastTransition.fromState;
-        }
-        for (let i = this.stateHistory.length - 1; i >= 0; i--) {
-            const toState = this.stateHistory[i].toState;
-            if (!toState)
-                continue;
-            if (toState.id === this.currentState?.id)
-                continue;
-            if (toState.html || toState.ariaSnapshot) {
-                return toState;
-            }
-        }
-        return null;
-    }
-    /**
-     * Load HTML content from file
-     */
-    loadHtmlFromFile(htmlFile) {
-        try {
-            const filePath = outputPath('states', htmlFile);
-            if (existsSync(filePath)) {
-                return readFileSync(filePath, 'utf8');
-            }
-            return null;
-        }
-        catch (error) {
-            debugLog('Failed to load HTML from file:', error);
-            return null;
-        }
-    }
     /**
      * Clear state history (useful for testing or reset)
      * Note: This preserves the current state, only clears navigation history
@@ -398,13 +285,7 @@ export class StateManager {
         this.stateHistory = [];
         this.allVisitedUrls.clear();
         this.stateChangeListeners = [];
-        this.knowledgeCache = [];
-        this.lastKnowledgeScan = null;
         this.nextStateId = 1;
-        // Clean up experience tracker if it has cleanup method
-        if (this.experienceTracker && typeof this.experienceTracker.cleanup === 'function') {
-            this.experienceTracker.cleanup();
-        }
         debugLog('StateManager cleanup completed');
     }
 }

package/dist/src/utils/aria.d.ts

@@ -4,7 +4,7 @@ export interface FocusAreaResult {
     name: string | null;
 }
 export declare const compactAriaSnapshot: (snapshot: string | null, keepNamed?: boolean) => string;
-export declare const diffAriaSnapshots: (previous: string | null, current: string | null) => string | null;
+export declare const diffAriaSnapshots: (previous: string | null, current: string | null) => AriaDiff;
 export declare const detectFocusArea: (snapshot: string | null) => FocusAreaResult;
 export declare const collectInteractiveNodes: (snapshot: string | null) => Array<Record<string, unknown>>;
 export interface FocusedElementInfo {
@@ -18,3 +18,8 @@ export declare function parseAriaLocator(ariaStr: string): {
     role: string;
     text: string;
 } | null;
+export declare const LARGE_ARIA_CHANGE_THRESHOLD = 50;
+export interface AriaDiff {
+    text: string | null;
+    count: number;
+}

package/dist/src/utils/aria.js

@@ -490,7 +490,9 @@ export const diffAriaSnapshots = (previous, current) => {
     const currTotals = countBy(curr.map((e) => e.summary));
     const byCount = diffByCount(prevTotals, currTotals);
     const renames = detectRenames(prev, curr, prevTotals, currTotals);
-    return formatDiff([...byCount.added, ...renames.added], [...byCount.removed, ...renames.removed], toggled);
+    const added = [...byCount.added, ...renames.added];
+    const removed = [...byCount.removed, ...renames.removed];
+    return { text: formatDiff(added, removed, toggled), count: added.length + removed.length + toggled.length };
 };
 export const detectFocusArea = (snapshot) => {
     let tree = parseSnapshot(snapshot);
@@ -543,3 +545,4 @@ export function parseAriaLocator(ariaStr) {
         return null;
     return { role: match[1], text: match[2] };
 }
+export const LARGE_ARIA_CHANGE_THRESHOLD = 50;

package/dist/src/utils/cache.d.ts

@@ -0,0 +1,15 @@
+export declare class TTLCache<T> {
+    store: Map<string, CacheEntry<T>>;
+    ttlMs: number;
+    constructor(ttlMs?: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    fetch(key: string, compute: () => Promise<T>): Promise<T>;
+    delete(key: string): void;
+    clear(): void;
+}
+type CacheEntry<T> = {
+    value: T;
+    at: number;
+};
+export {};

package/dist/src/utils/cache.js

@@ -0,0 +1,34 @@
+export class TTLCache {
+    store = new Map();
+    ttlMs;
+    constructor(ttlMs = Number.POSITIVE_INFINITY) {
+        this.ttlMs = ttlMs;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.at > this.ttlMs) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        this.store.set(key, { value, at: Date.now() });
+    }
+    async fetch(key, compute) {
+        const cached = this.get(key);
+        if (cached !== undefined)
+            return cached;
+        const value = await compute();
+        this.set(key, value);
+        return value;
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/src/utils/context-formatter.d.ts

@@ -21,5 +21,11 @@ export interface ContextData {
     combinedHtml?: string;
     research?: string;
 }
+export declare function formatHeadings(headings: {
+    h1?: string;
+    h2?: string;
+    h3?: string;
+    h4?: string;
+}): string[];
 export type ContextMode = 'attached' | 'compact' | 'full';
 export declare function formatContextSummary(data: ContextData, mode?: ContextMode): string;

package/dist/src/utils/context-formatter.js

@@ -10,6 +10,18 @@ function indent(text) {
         .map((line) => chalk.gray(`    ${line}`))
         .join('\n');
 }
+export function formatHeadings(headings) {
+    const lines = [];
+    if (headings.h1)
+        lines.push(`H1: ${headings.h1}`);
+    if (headings.h2)
+        lines.push(`H2: ${headings.h2}`);
+    if (headings.h3)
+        lines.push(`H3: ${headings.h3}`);
+    if (headings.h4)
+        lines.push(`H4: ${headings.h4}`);
+    return lines;
+}
 export function formatContextSummary(data, mode = 'compact') {
     if (mode === 'full') {
         return formatContextFull(data);
@@ -27,15 +39,7 @@ function formatContextAttached(data) {
         lines.push(indent(data.title));
     }
     lines.push('');
-    const headingLines = [];
-    if (data.headings.h1)
-        headingLines.push(`H1: ${data.headings.h1}`);
-    if (data.headings.h2)
-        headingLines.push(`H2: ${data.headings.h2}`);
-    if (data.headings.h3)
-        headingLines.push(`H3: ${data.headings.h3}`);
-    if (data.headings.h4)
-        headingLines.push(`H4: ${data.headings.h4}`);
+    const headingLines = formatHeadings(data.headings);
     if (headingLines.length > 0) {
         lines.push(section('HEADINGS') + chalk.gray(' (Auto-attached)'));
         lines.push(indent(headingLines.join('\n')));
@@ -88,15 +92,7 @@ function formatContextCompact(data) {
         lines.push(indent(data.title));
     }
     lines.push('');
-    const headingLines = [];
-    if (data.headings.h1)
-        headingLines.push(`H1: ${data.headings.h1}`);
-    if (data.headings.h2)
-        headingLines.push(`H2: ${data.headings.h2}`);
-    if (data.headings.h3)
-        headingLines.push(`H3: ${data.headings.h3}`);
-    if (data.headings.h4)
-        headingLines.push(`H4: ${data.headings.h4}`);
+    const headingLines = formatHeadings(data.headings);
     if (headingLines.length > 0) {
         lines.push(section('HEADINGS') + chalk.gray(' (Auto-attached)'));
         lines.push(indent(headingLines.join('\n')));
@@ -144,15 +140,7 @@ function formatContextFull(data) {
         lines.push(indent(data.title));
     }
     lines.push('');
-    const headingLines = [];
-    if (data.headings.h1)
-        headingLines.push(`H1: ${data.headings.h1}`);
-    if (data.headings.h2)
-        headingLines.push(`H2: ${data.headings.h2}`);
-    if (data.headings.h3)
-        headingLines.push(`H3: ${data.headings.h3}`);
-    if (data.headings.h4)
-        headingLines.push(`H4: ${data.headings.h4}`);
+    const headingLines = formatHeadings(data.headings);
     if (headingLines.length > 0) {
         lines.push(section('HEADINGS') + chalk.gray(' (Auto-attached)'));
         lines.push(indent(headingLines.join('\n')));

package/dist/src/utils/html.d.ts

@@ -2,8 +2,10 @@ import type * as parse5TreeAdapter from 'parse5/lib/tree-adapters/default';
 import type { HtmlConfig } from '../config.js';
 export declare const EXPLORBOT_ATTRS: {
     readonly area: "data-explorbot-area";
+    readonly coveredBy: "data-explorbot-covered-by";
     readonly context: "data-explorbot-context";
     readonly eidx: "data-explorbot-eidx";
+    readonly hit: "data-explorbot-hit";
     readonly variant: "data-explorbot-variant";
 };
 export declare const HTML_SELECTORS: {
@@ -41,8 +43,10 @@ export declare function inferHtmlRole(data: {
 export declare const ELEMENT_EXTRACTION_CONFIG: {
     readonly attrs: {
         readonly area: "data-explorbot-area";
+        readonly coveredBy: "data-explorbot-covered-by";
         readonly context: "data-explorbot-context";
         readonly eidx: "data-explorbot-eidx";
+        readonly hit: "data-explorbot-hit";
         readonly variant: "data-explorbot-variant";
     };
     readonly codeEditorMarkers: readonly ["monaco", "codemirror", "ace", "ace_editor", "code"];
@@ -70,6 +74,7 @@ export type ComponentScopeExtractionConfig = {
     interactiveControlSelector: string;
     limits: typeof HTML_EXTRACTION_LIMITS;
 };
+export declare function captureHtmlForSnapshot(): string;
 export declare function extractElementData(el: Element, config?: ElementExtractionConfig): {
     tag: string;
     text: string;

package/dist/src/utils/html.js

@@ -67,8 +67,10 @@ const INTERACTIVE_EVENT_ATTRIBUTES = new Set(['onclick', 'onchange', 'onblur', '
 const HIDDEN_CLASSES = new Set(['hidden', 'invisible', 'd-none', 'hide', 'dn', 'u-hidden', 'is-hidden', 'visually-hidden', 'sr-only', 'screen-reader-only', 'visuallyhidden', 'opacity-0']);
 export const EXPLORBOT_ATTRS = {
     area: 'data-explorbot-area',
+    coveredBy: 'data-explorbot-covered-by',
     context: 'data-explorbot-context',
     eidx: 'data-explorbot-eidx',
+    hit: 'data-explorbot-hit',
     variant: 'data-explorbot-variant',
 };
 export const HTML_SELECTORS = {
@@ -139,13 +141,41 @@ export const ELEMENT_EXTRACTION_CONFIG = {
         semanticContextContainer: HTML_SELECTORS.semanticContextContainer,
     },
 };
+export function captureHtmlForSnapshot() {
+    const clone = document.documentElement.cloneNode(true);
+    const liveControls = Array.from(document.querySelectorAll('input, textarea, select'));
+    const clonedControls = Array.from(clone.querySelectorAll('input, textarea, select'));
+    for (let i = 0; i < liveControls.length; i++) {
+        const source = liveControls[i];
+        const target = clonedControls[i];
+        if (!target)
+            continue;
+        if (source instanceof HTMLInputElement || source instanceof HTMLTextAreaElement) {
+            target.setAttribute('data-explorbot-value', source.value);
+        }
+        if (source instanceof HTMLInputElement && (source.type === 'checkbox' || source.type === 'radio')) {
+            let checked = 'false';
+            if (source.checked)
+                checked = 'true';
+            target.setAttribute('data-explorbot-checked', checked);
+        }
+        if (source instanceof HTMLSelectElement) {
+            target.setAttribute('data-explorbot-value', Array.from(source.selectedOptions)
+                .map((option) => option.value)
+                .join(','));
+        }
+    }
+    return clone.outerHTML;
+}
 export function extractElementData(el, config) {
     const cfg = config ||
         {
             attrs: {
                 area: 'data-explorbot-area',
+                coveredBy: 'data-explorbot-covered-by',
                 context: 'data-explorbot-context',
                 eidx: 'data-explorbot-eidx',
+                hit: 'data-explorbot-hit',
                 variant: 'data-explorbot-variant',
             },
             codeEditorMarkers: ['monaco', 'codemirror', 'ace', 'ace_editor', 'code'],
@@ -223,6 +253,43 @@ export function extractElementData(el, config) {
             tokens.add('navigates');
         return Array.from(tokens).slice(0, 8);
     }
+    function describeOverlappingElement(target) {
+        const parts = [target.tagName.toLowerCase()];
+        const role = target.getAttribute('role');
+        const ariaLabel = target.getAttribute('aria-label');
+        const id = target.getAttribute('id');
+        const className = (target.getAttribute('class') || '').split(/\s+/).filter(Boolean).slice(0, 3).join('.');
+        if (id)
+            parts.push(`#${id.slice(0, 40)}`);
+        if (className)
+            parts.push(`.${className.slice(0, 80)}`);
+        if (role)
+            parts.push(`[role="${role.slice(0, 40)}"]`);
+        if (ariaLabel)
+            parts.push(`[aria-label="${ariaLabel.slice(0, 80)}"]`);
+        return parts.join('');
+    }
+    function inspectHitTarget(target, rect) {
+        const viewportPoints = [
+            { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 },
+            { x: rect.left + Math.min(rect.width - 1, Math.max(1, rect.width * 0.25)), y: rect.top + Math.min(rect.height - 1, Math.max(1, rect.height * 0.25)) },
+            { x: rect.left + Math.min(rect.width - 1, Math.max(1, rect.width * 0.75)), y: rect.top + Math.min(rect.height - 1, Math.max(1, rect.height * 0.75)) },
+        ].filter((point) => point.x >= 0 && point.y >= 0 && point.x <= window.innerWidth && point.y <= window.innerHeight);
+        if (viewportPoints.length === 0) {
+            return { hit: 'offscreen' };
+        }
+        for (const point of viewportPoints) {
+            const top = document.elementFromPoint(point.x, point.y);
+            if (!top)
+                continue;
+            if (top === target || target.contains(top)) {
+                return { hit: 'target' };
+            }
+        }
+        const centerPoint = viewportPoints[0];
+        const top = document.elementFromPoint(centerPoint.x, centerPoint.y);
+        return { hit: 'covered', coveredBy: top ? describeOverlappingElement(top) : undefined };
+    }
     function isEmbeddedCodeEditorFrame(target) {
         const src = (target.getAttribute('src') || '').toLowerCase();
         const markerSelector = cfg.codeEditorMarkers.map((marker) => `[class*="${marker}"]`).join(', ');
@@ -329,6 +396,10 @@ export function extractElementData(el, config) {
     allAttrs[cfg.attrs.area] = areaHints.join('|');
     allAttrs[cfg.attrs.context] = findContextLabel(el);
     allAttrs[cfg.attrs.variant] = collectVariantHints(el).join('|');
+    const hitTarget = inspectHitTarget(el, rect);
+    allAttrs[cfg.attrs.hit] = hitTarget.hit;
+    if (hitTarget.coveredBy)
+        allAttrs[cfg.attrs.coveredBy] = hitTarget.coveredBy;
     return {
         tag: el.tagName.toLowerCase(),
         text: normalizeText(el.textContent || '').slice(0, cfg.maxTextLength),

package/dist/src/utils/markdown-files.d.ts

@@ -0,0 +1,10 @@
+export declare function loadMarkdownFiles(dir: string, options?: {
+    recursive?: boolean;
+    onError?: (filePath: string, error: unknown) => void;
+}): MarkdownFile[];
+export interface MarkdownFile {
+    filePath: string;
+    content: string;
+    data: Record<string, any>;
+    mtime: Date;
+}

package/dist/src/utils/markdown-files.js

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+export function loadMarkdownFiles(dir, options = {}) {
+    if (!existsSync(dir))
+        return [];
+    const results = [];
+    const files = readdirSync(dir, { recursive: options.recursive === true })
+        .filter((file) => typeof file === 'string' && file.endsWith('.md'))
+        .map((file) => join(dir, file));
+    for (const filePath of files) {
+        try {
+            const parsed = matter(readFileSync(filePath, 'utf8'));
+            results.push({ filePath, content: parsed.content, data: parsed.data, mtime: statSync(filePath).mtime });
+        }
+        catch (error) {
+            options.onError?.(filePath, error);
+        }
+    }
+    return results;
+}

package/dist/src/utils/markdown-query.d.ts

@@ -30,11 +30,17 @@ export declare class MarkdownQuery {
     get(): string;
     toJson(): Record<string, string>[];
     replace(content: string): string;
+    replaceEach(replacer: (match: MarkdownQuery, index: number) => string): string;
     count(): number;
     first(): MarkdownQuery;
     last(): MarkdownQuery;
     before(): MarkdownQuery;
     after(): MarkdownQuery;
     each(): MarkdownQuery[];
+    meta(): Array<{
+        type: string;
+        depth: number | null;
+        text: string;
+    }>;
 }
 export declare function mdq(source: string): MarkdownQuery;

package/dist/src/utils/markdown-query.js

@@ -341,6 +341,9 @@ export class MarkdownQuery {
         return results;
     }
     replace(content) {
+        return this.replaceEach(() => content);
+    }
+    replaceEach(replacer) {
         const sorted = [...this.matches].sort((a, b) => a.start - b.start);
         const kept = [];
         let lastEnd = -1;
@@ -350,10 +353,11 @@ export class MarkdownQuery {
             kept.push(range);
             lastEnd = range.start + range.length;
         }
+        const replacements = kept.map((range, index) => replacer(new MarkdownQuery(this.source, [range]), index));
         let result = this.source;
         for (let i = kept.length - 1; i >= 0; i--) {
             const range = kept[i];
-            result = result.slice(0, range.start) + content + result.slice(range.start + range.length);
+            result = result.slice(0, range.start) + replacements[i] + result.slice(range.start + range.length);
         }
         return result;
     }
@@ -386,6 +390,15 @@ export class MarkdownQuery {
     each() {
         return this.matches.map((m) => new MarkdownQuery(this.source, [m]));
     }
+    meta() {
+        return this.matches.map((range) => {
+            const token = range.token;
+            let depth = null;
+            if (token.type === 'heading')
+                depth = token.depth;
+            return { type: token.type, depth, text: getTokenText(range.token) };
+        });
+    }
 }
 export function mdq(source) {
     return new MarkdownQuery(source);

package/dist/src/utils/page-readiness.d.ts

@@ -1,4 +1,5 @@
 export declare function waitForPageReadiness(page: any, options?: PageReadinessOptions): Promise<void>;
+export declare function sleep(ms: number): Promise<void>;
 interface PageReadinessOptions {
     timeout?: number;
     spinnerSelectors?: string[];

package/dist/src/utils/page-readiness.js

@@ -43,6 +43,6 @@ function waitForPageBodyContent(page, timeout) {
     }, undefined, { timeout })
         .catch(() => { });
 }
-function sleep(ms) {
+export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/src/utils/secrets.js

@@ -1,4 +1,5 @@
 const MIN_SECRET_LENGTH = 4;
+const SECRET_NAME_TOKENS = ['password', 'passwd', 'secret', 'token', 'apikey', 'api_key', 'credential', 'private_key', 'privatekey', 'access_key', 'jwt', 'auth', 'bearer', 'authorization', 'cert', 'certificate'];
 const secretValues = new Set();
 export function registerSecret(value) {
     if (!value)
@@ -11,7 +12,7 @@ export function redactSecrets(text) {
     if (!text)
         return text;
     let result = text;
-    for (const value of secretValues) {
+    for (const value of [...secretValues].sort((a, b) => b.length - a.length)) {
         if (!result.includes(value))
             continue;
         result = result.split(value).join('***REDACTED***');
@@ -21,7 +22,6 @@ export function redactSecrets(text) {
 export function clearRegisteredSecrets() {
     secretValues.clear();
 }
-const SECRET_NAME_TOKENS = ['password', 'passwd', 'secret', 'token', 'apikey', 'api_key', 'credential', 'private_key', 'privatekey', 'access_key'];
 export function isSecretName(name) {
     const lower = name.toLowerCase();
     return SECRET_NAME_TOKENS.some((token) => lower.includes(token));

package/dist/src/utils/strings.d.ts

@@ -1,3 +1,5 @@
 export declare function truncateJson(input: any): string;
+export declare function slugify(text: string): string;
+export declare function normalizeInlineText(text: string): string;
 export declare function sanitizeFilename(name: string): string;
 export declare function safeFilename(name: string, ext?: string, maxBytes?: number): string;

package/dist/src/utils/strings.js

@@ -5,6 +5,16 @@ export function truncateJson(input) {
     const str = JSON.stringify(input);
     return str.length <= 80 ? str : `${str.slice(0, 77)}...`;
 }
+export function slugify(text) {
+    return text
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .toLowerCase();
+}
+export function normalizeInlineText(text) {
+    return text.normalize('NFKC').replace(/\s+/g, ' ').trim();
+}
 export function sanitizeFilename(name) {
     return name
         .toLowerCase()