explorbot 0.1.5 → 0.1.7

package/src/experience-tracker.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import matter from 'gray-matter';
+import { marked, type Tokens } from 'marked';
 import type { ActionResult } from './action-result.js';
 import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
@@ -332,6 +333,133 @@ ${filteredCode}
 
     return results;
   }
+
+  getExperienceTableOfContents(state: ActionResult, options?: { includeDescendantExperience?: boolean }): ExperienceTocEntry[] {
+    const records = this.getRelevantExperience(state, options);
+    if (records.length === 0) return [];
+
+    const sorted = [...records].sort((a, b) => {
+      const aHash = basename(a.filePath, '.md');
+      const bHash = basename(b.filePath, '.md');
+      return aHash.localeCompare(bHash);
+    });
+
+    const toc: ExperienceTocEntry[] = [];
+    for (let i = 0; i < sorted.length; i++) {
+      const record = sorted[i];
+      const fileHash = basename(record.filePath, '.md');
+      const url = (record.data as WebPageState)?.url || '';
+      const sections = listTocHeadings(record.content);
+      if (sections.length === 0) continue;
+      toc.push({
+        fileTag: indexToLetters(i),
+        fileHash,
+        url,
+        sections,
+      });
+    }
+    return toc;
+  }
+
+  getExperienceSection(fileTag: string, sectionIndex: number, state: ActionResult, options?: { includeDescendantExperience?: boolean }): { title: string; url: string; content: string } | null {
+    const toc = this.getExperienceTableOfContents(state, options);
+    const entry = toc.find((e) => e.fileTag === fileTag);
+    if (!entry) return null;
+
+    const filePath = this.findExperienceFileByHash(entry.fileHash);
+    if (!filePath) return null;
+
+    const { content } = this.readExperienceFile(entry.fileHash);
+    const extracted = extractHeadingSection(content, sectionIndex);
+    if (!extracted) return null;
+
+    return { title: extracted.title, url: entry.url, content: extracted.body };
+  }
+
+  private findExperienceFileByHash(fileHash: string): string | null {
+    for (const dir of this.getExperienceDirectories()) {
+      const candidate = join(dir, `${fileHash}.md`);
+      if (existsSync(candidate)) return candidate;
+    }
+    return null;
+  }
+}
+
+function listTocHeadings(content: string): { index: number; level: 2 | 3; title: string }[] {
+  const tokens = marked.lexer(content);
+  const result: { index: number; level: 2 | 3; title: string }[] = [];
+  let index = 0;
+  for (const token of tokens) {
+    if (token.type !== 'heading') continue;
+    const heading = token as Tokens.Heading;
+    if (heading.depth !== 2 && heading.depth !== 3) continue;
+    index++;
+    result.push({ index, level: heading.depth as 2 | 3, title: heading.text });
+  }
+  return result;
+}
+
+function extractHeadingSection(content: string, sectionIndex: number): { title: string; body: string } | null {
+  const tokens = marked.lexer(content);
+  const matching: { tokenIdx: number; depth: number; text: string }[] = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type !== 'heading') continue;
+    const heading = token as Tokens.Heading;
+    if (heading.depth !== 2 && heading.depth !== 3) continue;
+    matching.push({ tokenIdx: i, depth: heading.depth, text: heading.text });
+  }
+
+  if (sectionIndex < 1 || sectionIndex > matching.length) return null;
+
+  const target = matching[sectionIndex - 1];
+  let endTokenIdx = tokens.length;
+  for (let j = target.tokenIdx + 1; j < tokens.length; j++) {
+    const token = tokens[j];
+    if (token.type !== 'heading') continue;
+    if ((token as Tokens.Heading).depth <= target.depth) {
+      endTokenIdx = j;
+      break;
+    }
+  }
+
+  const body = tokens
+    .slice(target.tokenIdx, endTokenIdx)
+    .map((t) => (t as any).raw || '')
+    .join('');
+  return { title: target.text, body };
+}
+
+function indexToLetters(index: number): string {
+  let n = index;
+  let result = '';
+  while (true) {
+    result = String.fromCharCode(65 + (n % 26)) + result;
+    n = Math.floor(n / 26);
+    if (n === 0) break;
+    n -= 1;
+  }
+  return result;
+}
+
+export function renderExperienceToc(toc: ExperienceTocEntry[]): string {
+  if (toc.length === 0) return '';
+
+  const lines: string[] = [];
+  lines.push('<experience>');
+  lines.push('Past experience for this page. Call learn_experience({ fileTag, sectionIndex }) to read a section.');
+  lines.push('');
+  for (const entry of toc) {
+    lines.push(`File ${entry.fileTag} ${entry.url}:`);
+    for (const section of entry.sections) {
+      const prefix = '#'.repeat(section.level);
+      lines.push(`  ${entry.fileTag}.${section.index} ${prefix} ${section.title}`);
+    }
+    lines.push('');
+  }
+  lines.push('</experience>');
+  return lines.join('\n');
 }
 
 export interface SessionStep {
@@ -348,3 +476,10 @@ export interface SessionExperienceEntry {
   steps: SessionStep[];
   relatedUrls?: string[];
 }
+
+export interface ExperienceTocEntry {
+  fileTag: string;
+  fileHash: string;
+  url: string;
+  sections: { index: number; level: 2 | 3; title: string }[];
+}

package/src/explorbot.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
+import { ActionResult } from './action-result.ts';
 import { ApiClient } from './api/api-client.ts';
 import { RequestStore } from './api/request-store.ts';
 import { loadSpec } from './api/spec-reader.ts';
@@ -182,8 +183,14 @@ export class ExplorBot {
     return (this.agents.pilot ||= this.createAgent(({ ai, explorer }) => {
       const researcher = this.agentResearcher();
       const navigator = this.agentNavigator();
-      const tools = createAgentTools({ explorer, researcher, navigator });
-      return new Pilot(ai, tools, researcher, explorer);
+      const stateManager = explorer.getStateManager();
+      const experienceTracker = stateManager.getExperienceTracker();
+      const getState = () => {
+        const state = stateManager.getCurrentState();
+        return state ? ActionResult.fromState(state) : null;
+      };
+      const tools = createAgentTools({ explorer, researcher, navigator, experienceTracker, getState });
+      return new Pilot(ai, tools, researcher, explorer, experienceTracker);
     }));
   }
 

package/src/utils/aria.ts

@@ -355,8 +355,41 @@ export interface FocusAreaResult {
   name: string | null;
 }
 
+const CLOSE_OVERLAY_BUTTON_RE = /^close\s+(modal|dialog|popup|drawer|panel|sheet)\b/i;
+
+const findOverlayByCloseButton = (nodeList: AriaNode[]): FocusAreaResult | null => {
+  const closeIdx = nodeList.findIndex((n) => n.role === 'button' && CLOSE_OVERLAY_BUTTON_RE.test(n.name || ''));
+  if (closeIdx !== -1) {
+    let heading: AriaNode | undefined;
+    for (let i = closeIdx - 1; i >= 0; i--) {
+      if (nodeList[i].role === 'heading' && nodeList[i].name) {
+        heading = nodeList[i];
+        break;
+      }
+    }
+    if (!heading) {
+      for (let i = closeIdx + 1; i < nodeList.length; i++) {
+        if (nodeList[i].role === 'heading' && nodeList[i].name) {
+          heading = nodeList[i];
+          break;
+        }
+      }
+    }
+    return {
+      detected: true,
+      type: 'dialog',
+      name: heading?.name || null,
+    };
+  }
+  for (const node of nodeList) {
+    const inner = findOverlayByCloseButton(node.children);
+    if (inner) return inner;
+  }
+  return null;
+};
+
 export const detectFocusArea = (snapshot: string | null): FocusAreaResult => {
-  const nodes = parseAriaSnapshot(snapshot);
+  const nodes = parseAriaSnapshot(snapshot, true);
 
   const findFocusArea = (nodeList: AriaNode[]): FocusAreaResult | null => {
     for (const node of nodeList) {
@@ -385,7 +418,12 @@ export const detectFocusArea = (snapshot: string | null): FocusAreaResult => {
   };
 
   const result = findFocusArea(nodes);
-  return result || { detected: false, type: null, name: null };
+  if (result) return result;
+
+  const fallback = findOverlayByCloseButton(nodes);
+  if (fallback && fallback.name) return fallback;
+
+  return { detected: false, type: null, name: null };
 };
 
 export const collectInteractiveNodes = (snapshot: string | null): Array<Record<string, unknown>> => {