explorbot 0.1.10 → 0.1.12

package/src/utils/aria.ts

@@ -644,9 +644,18 @@ const resolveDisplayName = (node: AriaNode): string | undefined => {
   return undefined;
 };
 
+const SIBLING_COLLAPSE_THRESHOLD = 50;
+const SIBLING_COLLAPSE_KEEP_EACH_SIDE = 5;
+
 const serializeAriaNodes = (nodes: AriaNode[], depth = 0): string => {
   const lines: string[] = [];
-  for (const node of nodes) {
+  const collapsed = collapseSimilarSiblingRuns(nodes, depth);
+  for (const entry of collapsed) {
+    if (entry.placeholder) {
+      lines.push(entry.placeholder);
+      continue;
+    }
+    const node = entry.node!;
     const indent = '  '.repeat(depth);
     let line = `${indent}- ${renderNodeLine(node.role, resolveDisplayName(node), node.attributes, node.value)}`;
     if (node.children.length > 0) {
@@ -660,6 +669,34 @@ const serializeAriaNodes = (nodes: AriaNode[], depth = 0): string => {
   return lines.join('\n');
 };
 
+type SerializeEntry = { node?: AriaNode; placeholder?: string };
+
+const collapseSimilarSiblingRuns = (nodes: AriaNode[], depth: number): SerializeEntry[] => {
+  const result: SerializeEntry[] = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const role = nodes[i].role;
+    let j = i;
+    while (j < nodes.length && nodes[j].role === role) j++;
+    const runLength = j - i;
+    if (runLength > SIBLING_COLLAPSE_THRESHOLD) {
+      for (let k = i; k < i + SIBLING_COLLAPSE_KEEP_EACH_SIDE; k++) {
+        result.push({ node: nodes[k] });
+      }
+      const omitted = runLength - SIBLING_COLLAPSE_KEEP_EACH_SIDE * 2;
+      const indent = '  '.repeat(depth);
+      result.push({ placeholder: `${indent}- ...${omitted} similar "${role}" items omitted...` });
+      for (let k = j - SIBLING_COLLAPSE_KEEP_EACH_SIDE; k < j; k++) {
+        result.push({ node: nodes[k] });
+      }
+    } else {
+      for (let k = i; k < j; k++) result.push({ node: nodes[k] });
+    }
+    i = j;
+  }
+  return result;
+};
+
 export const compactAriaSnapshot = (snapshot: string | null, keepNamed = false): string => {
   if (!snapshot) return '';
   const nodes = parseAriaSnapshot(snapshot, keepNamed);

package/src/utils/error-page.ts

@@ -4,22 +4,37 @@ import { isBodyEmpty } from './html.js';
 const HTTP_ERRORS = ['400 Bad Request', '401 Unauthorized', '403 Forbidden', '404 Not Found', '405 Method Not Allowed', '408 Request Timeout', '500 Internal Server Error', '502 Bad Gateway', '503 Service Unavailable', '504 Gateway Timeout'];
 
 const SMALL_PAGE_THRESHOLD = 500;
+const LOADING_WORD = /\bloading\b/i;
 
-export function isErrorPage(actionResult: ActionResult): boolean {
-  const checkFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean) as string[];
+export type PageCondition = 'ok' | 'loading' | 'error';
+
+export function detectPageCondition(actionResult: ActionResult): PageCondition {
+  const headingFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean) as string[];
 
-  for (const field of checkFields) {
+  for (const field of headingFields) {
     for (const error of HTTP_ERRORS) {
-      if (field.toLowerCase().includes(error.toLowerCase())) return true;
+      if (field.toLowerCase().includes(error.toLowerCase())) return 'error';
     }
   }
 
-  if (!actionResult.html || isBodyEmpty(actionResult.html)) return true;
+  const aria = actionResult.ariaSnapshot || '';
+  if (/\bprogressbar\b/i.test(aria)) return 'loading';
+  if (/\[busy\]/.test(aria)) return 'loading';
+
+  for (const field of headingFields) {
+    if (LOADING_WORD.test(field)) return 'loading';
+  }
+
+  if (!actionResult.html || isBodyEmpty(actionResult.html)) return 'loading';
 
   const bodyMatch = actionResult.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
-  if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD) return true;
+  if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD) return 'loading';
+
+  return 'ok';
+}
 
-  return false;
+export function isErrorPage(actionResult: ActionResult): boolean {
+  return detectPageCondition(actionResult) === 'error';
 }
 
 export class ErrorPageError extends Error {

package/src/utils/next-steps.ts

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { tag } from './logger.js';
+
+export interface NextStepCommand {
+  label: string;
+  command: string;
+}
+
+export interface NextStepSection {
+  label: string;
+  path?: string;
+  commands?: NextStepCommand[];
+}
+
+export function relativeToCwd(absPath: string): string {
+  const rel = path.relative(process.cwd(), absPath);
+  return rel || '.';
+}
+
+export function printNextSteps(sections: NextStepSection[]): void {
+  if (sections.length === 0) return;
+
+  const blocks: string[] = [];
+  for (const section of sections) {
+    const lines: string[] = [];
+    const headerPath = section.path ? relativeToCwd(section.path) : '';
+    lines.push(headerPath ? `${section.label}: ${headerPath}` : section.label);
+
+    const commands = section.commands || [];
+    if (commands.length > 0) {
+      const labeled = commands.filter((c) => c.label);
+      const maxLabel = labeled.length > 0 ? Math.max(...labeled.map((c) => c.label.length)) : 0;
+      for (const cmd of commands) {
+        if (!cmd.label) {
+          lines.push(`  ${cmd.command}`);
+          continue;
+        }
+        const padded = `${cmd.label}:`.padEnd(maxLabel + 2);
+        lines.push(`  ${padded} ${cmd.command}`);
+      }
+    }
+    blocks.push(lines.join('\n'));
+  }
+
+  for (let i = 0; i < blocks.length; i++) {
+    if (i > 0) tag('info').log('');
+    for (const line of blocks[i].split('\n')) {
+      tag('info').log(line);
+    }
+  }
+}

package/src/utils/strings.ts

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+
 export function truncateJson(input: any): string {
   if (!input) return '';
   const str = JSON.stringify(input);
@@ -11,3 +13,18 @@ export function sanitizeFilename(name: string): string {
     .replace(/^_+|_+$/g, '')
     .slice(0, 50);
 }
+
+export function safeFilename(name: string, ext = '', maxBytes = 240): string {
+  const sanitized = name.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+  const extBytes = Buffer.byteLength(ext, 'utf8');
+  const budget = maxBytes - extBytes;
+  if (Buffer.byteLength(sanitized, 'utf8') <= budget) return sanitized + ext;
+
+  const hash = createHash('sha1').update(name).digest('hex').slice(0, 8);
+  const suffix = `_${hash}`;
+  let truncated = sanitized;
+  while (Buffer.byteLength(truncated + suffix, 'utf8') > budget && truncated.length > 0) {
+    truncated = truncated.slice(0, -1);
+  }
+  return truncated + suffix + ext;
+}