explorbot 0.1.25 → 0.1.27

package/src/commands/explore-command.ts

@@ -7,7 +7,6 @@ import { type Plan, type Test, TestResult } from '../test-plan.js';
 import { getCliName } from '../utils/cli-name.ts';
 import { ErrorPageError } from '../utils/error-page.ts';
 import { tag } from '../utils/logger.js';
-import { jsonToTable } from '../utils/markdown-parser.js';
 import { type NextStepSection, printNextSteps, relativeToCwd } from '../utils/next-steps.ts';
 import { safeFilename } from '../utils/strings.ts';
 import { BaseCommand, type Suggestion } from './base-command.js';
@@ -88,14 +87,14 @@ export class ExploreCommand extends BaseCommand {
       const t = tests[i];
       lines.push(`  ${String(i + 1).padStart(2)}. [${this.originLabel(t)}] [${t.priority.padEnd(9)}] ${t.scenario}`);
     }
-    tag('multiline').log(lines.join('\n'));
+    tag('multiline').log(lines.join('\n'), { maxLines: 24 });
   }
 
   private async runFreshMode(mainUrl: string | undefined, feature: string | undefined, styles?: string[]): Promise<void> {
     await this.runAllStyles(mainUrl, feature, undefined, undefined, styles);
+    this.rememberCurrentPlan();
     const mainPlan = this.explorBot.getCurrentPlan();
     if (!mainPlan) return;
-    this.completedPlans.push(mainPlan);
 
     if (feature || this.isLimitReached()) return;
 
@@ -270,6 +269,7 @@ export class ExploreCommand extends BaseCommand {
     const styleList = styles ?? Object.keys(getStyles());
     let fresh = true;
     for (const style of styleList) {
+      if (this.isLimitReached()) break;
       if (!fresh && pageUrl && !this.dryRun) {
         await this.explorBot.visit(pageUrl);
       }
@@ -278,10 +278,19 @@ export class ExploreCommand extends BaseCommand {
       if (this.dryRun) opts.noSave = true;
       await this.planWithRetry(feature, opts, pageUrl);
       await this.runPendingTests();
+      this.rememberCurrentPlan();
       fresh = false;
     }
   }
 
+  private rememberCurrentPlan(): void {
+    const plan = this.explorBot.getCurrentPlan();
+    if (!plan) return;
+    if (this.completedPlans.includes(plan)) return;
+    if (plan.tests.every((test) => test.startTime == null)) return;
+    this.completedPlans.push(plan);
+  }
+
   private async planWithRetry(feature: string | undefined, opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[]; noSave?: boolean }, pageUrl?: string): Promise<void> {
     const before = new Set(this.explorBot.getCurrentPlan()?.tests ?? []);
 
@@ -401,34 +410,63 @@ export class ExploreCommand extends BaseCommand {
 
     if (allTests.length === 0) return;
 
-    const hasSubPages = this.completedPlans.length > 1;
+    const hasSubPages = new Set(this.completedPlans.map((plan) => plan.title)).size > 1;
     const hasOrigin = this.oldTestRefs.size > 0;
-    const rows = allTests.map(({ test, planTitle }, index) => {
+    const completed = allTests.map(({ test, planTitle }, index) => {
       const durationMs = test.getDurationMs();
       const duration = durationMs != null ? `${(durationMs / 1000).toFixed(1)}s` : '-';
       let status = 'failed';
       if (test.isSuccessful) status = 'passed';
       else if (test.isSkipped) status = 'skipped';
-      const row: Record<string, string> = {
-        '#': String(index + 1),
-        Status: status,
-        Title: test.scenario.replace(/\|/g, '-'),
-        Priority: test.priority,
-        Time: duration,
-        Steps: String(Object.keys(test.notes).length),
+      return {
+        index: index + 1,
+        status,
+        title: test.scenario.replace(/\s+/g, ' ').trim(),
+        priority: test.priority,
+        duration,
+        durationMs: durationMs ?? 0,
+        steps: Object.keys(test.notes).length,
+        origin: hasOrigin ? this.originLabel(test) : '',
+        planTitle: hasSubPages ? planTitle : '',
       };
-      if (hasOrigin) {
-        row.Origin = this.originLabel(test);
+    });
+    const passed = completed.filter((t) => t.status === 'passed').length;
+    const failed = completed.filter((t) => t.status === 'failed').length;
+    const skipped = completed.filter((t) => t.status === 'skipped').length;
+    const totalSeconds = completed.reduce((sum, t) => sum + t.durationMs, 0) / 1000;
+    const lines = [`Results: ${passed} passed, ${failed} failed, ${skipped} skipped - ${formatDuration(totalSeconds)}`];
+
+    const failedTests = completed.filter((t) => t.status === 'failed');
+    if (failedTests.length > 0) {
+      lines.push('', 'Failed tests:');
+      for (const test of failedTests) {
+        lines.push(`  #${test.index} [${test.priority}] ${test.title} (${test.duration}, ${test.steps} steps)`);
       }
-      if (hasSubPages) {
-        row.Plan = planTitle;
+    }
+
+    const slowTests = completed
+      .filter((t) => t.durationMs >= 1000)
+      .sort((a, b) => b.durationMs - a.durationMs)
+      .slice(0, 3);
+    if (slowTests.length > 0) {
+      lines.push('', 'Slowest tests:');
+      for (const test of slowTests) {
+        lines.push(`  #${test.index} ${test.duration} - ${test.title}`);
       }
-      return row;
-    });
-    const columns = ['#', 'Status', 'Title', 'Priority', 'Time', 'Steps'];
-    if (hasOrigin) columns.push('Origin');
-    if (hasSubPages) columns.push('Plan');
-    tag('multiline').log(jsonToTable(rows, columns));
+    }
+
+    const detailLines = completed
+      .map((test) => {
+        const details = [test.origin, test.planTitle].filter(Boolean).join(' - ');
+        return details ? `  #${test.index} ${details}` : '';
+      })
+      .filter(Boolean);
+    if (detailLines.length > 0) {
+      lines.push('', 'Details:');
+      lines.push(...detailLines);
+    }
+
+    tag('multiline').log(lines.join('\n'));
     tag('info').log(`${figureSet.tick} ${allTests.length} tests completed`);
   }
 
@@ -463,8 +501,8 @@ export class ExploreCommand extends BaseCommand {
     }
 
     if (screencasts.length > 0) {
-      const commands = screencasts.map((f) => ({ label: '', command: relativeToCwd(f) }));
       const screencastDir = relativeToCwd(outputPath('screencasts'));
+      const commands = [{ label: 'Folder', command: screencastDir }];
       const planSlugs = [...new Set(this.completedPlans.map((p) => safeFilename(p.title)).filter(Boolean))];
       for (const slug of planSlugs) {
         commands.push({ label: 'Browse plan', command: `ls ${screencastDir}/${slug}-*` });
@@ -529,3 +567,10 @@ function parseRatio(s: string): number | null {
   if (Number.isNaN(n) || n < 0 || n > 1) return null;
   return n;
 }
+
+function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}

package/src/commands/test-command.ts

@@ -69,7 +69,8 @@ export class TestCommand extends BaseCommand {
 
     tag('info').log(`Launching ${toExecute.length} test scenario(s).`);
     const tester = this.explorBot.agentTester();
-    for (const test of toExecute) {
+    for (const [index, test] of toExecute.entries()) {
+      tag('info').log(`Starting test ${index + 1}/${toExecute.length}: ${test.scenario}`);
       await tester.test(test);
     }
     tag('success').log('Test execution finished');

package/src/components/App.tsx

@@ -14,7 +14,6 @@ import InputPane from './InputPane.js';
 import InputReadline from './InputReadline.js';
 import LogPane from './LogPane.js';
 import PlanEditor from './PlanEditor.js';
-import PlanPane, { type PlanSummary } from './PlanPane.js';
 import SessionTimer from './SessionTimer.js';
 import StateTransitionPane from './StateTransitionPane.js';
 import TaskPane, { WINDOW_SIZE } from './TaskPane.js';
@@ -158,42 +157,20 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
 
   const planRef = useRef<ReturnType<typeof explorBot.getCurrentPlan>>(undefined);
   const unsubscribeRef = useRef<(() => void) | undefined>(undefined);
-  const [completedPlans, setCompletedPlans] = useState<PlanSummary[]>([]);
-  const [activePlanInfo, setActivePlanInfo] = useState<PlanSummary | null>(null);
 
   useEffect(() => {
-    const makeSummary = (plan: NonNullable<ReturnType<typeof explorBot.getCurrentPlan>>): PlanSummary => {
-      const enabled = plan.tests.filter((t) => t.enabled);
-      return {
-        title: plan.title,
-        testCount: enabled.length,
-        passed: enabled.filter((t) => t.isSuccessful).length,
-        failed: enabled.filter((t) => t.hasFailed).length,
-      };
-    };
-
     const subscribeToPlan = (plan: NonNullable<ReturnType<typeof explorBot.getCurrentPlan>>) => {
       if (unsubscribeRef.current) unsubscribeRef.current();
 
-      if (planRef.current && planRef.current !== plan && planRef.current.tests.length > 0) {
-        const summary = makeSummary(planRef.current);
-        setCompletedPlans((prev) => {
-          if (prev.some((p) => p.title === summary.title)) return prev;
-          return [...prev, summary];
-        });
-      }
-
       planRef.current = plan;
       tasksRef.current = [...plan.tests];
       setTasks(tasksRef.current);
       setTaskScrollOffset(0);
-      setActivePlanInfo(makeSummary(plan));
 
       let lastInProgressIdx = -1;
       unsubscribeRef.current = plan.onTestsChange((updatedTests) => {
         tasksRef.current = [...updatedTests];
         setTasks(tasksRef.current);
-        setActivePlanInfo(makeSummary(plan));
         const inProgressIdx = updatedTests.findIndex((t) => t.status === 'in_progress' && t.enabled);
         if (inProgressIdx >= 0 && inProgressIdx !== lastInProgressIdx) {
           lastInProgressIdx = inProgressIdx;
@@ -211,17 +188,9 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         subscribeToPlan(currentPlan);
       } else if (!currentPlan && planRef.current) {
         if (unsubscribeRef.current) unsubscribeRef.current();
-        if (planRef.current.tests.length > 0) {
-          const summary = makeSummary(planRef.current);
-          setCompletedPlans((prev) => {
-            if (prev.some((p) => p.title === summary.title)) return prev;
-            return [...prev, summary];
-          });
-        }
         planRef.current = undefined;
         tasksRef.current = [];
         setTasks([]);
-        setActivePlanInfo(null);
       }
     }, 2000);
 
@@ -389,8 +358,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         )}
         <Autocomplete />
       </Box>
-
-      <PlanPane completedPlans={completedPlans} activePlan={activePlanInfo} />
     </Box>
   );
 }

package/src/components/LogPane.tsx

@@ -22,7 +22,6 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
   const pendingLogsRef = React.useRef<LogEntry[]>([]);
   const flushTimeoutRef = React.useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  const MAX_MULTILINE_LINES = 16;
   const MAX_STEP_LINES = 8;
   const MAX_SUBSTEP_LINES = 6;
 
@@ -115,6 +114,8 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
         return { color: 'yellow' as const };
       case 'debug':
         return { color: 'gray' as const, dimColor: true };
+      case 'operation':
+        return { color: 'gray' as const, dimColor: true };
       case 'substep':
         return { color: 'gray' as const, dimColor: true };
       case 'step':
@@ -146,7 +147,8 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
       const cleaned = stripAnsi(dedent(log.content));
       const parsed = parseMarkdownToTerminal(cleaned);
       const lines = parsed.split('\n');
-      const truncated = lines.length > MAX_MULTILINE_LINES ? `${lines.slice(0, MAX_MULTILINE_LINES).join('\n')}\n... (${lines.length - MAX_MULTILINE_LINES} more lines)` : parsed;
+      const maxLines = log.maxLines || 16;
+      const truncated = lines.length > maxLines ? `${lines.slice(0, maxLines).join('\n')}\n... (${lines.length - maxLines} more lines)` : parsed;
       return (
         <Box key={index} borderStyle="classic" borderLeft={false} borderRight={false} marginY={1} padding={1} borderColor="dim" overflow="hidden">
           <Text color="gray" dimColor>
@@ -163,6 +165,7 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
         type: 'multiline',
         content: `HTML Content:\n\n${markdown}`,
         timestamp: log.timestamp,
+        maxLines: 10,
       };
 
       return renderLogEntry(multilineLog, index);
@@ -182,6 +185,18 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
       );
     }
 
+    if (log.type === 'operation') {
+      return (
+        <Box key={index} marginLeft={2} flexDirection="column">
+          {lines.map((line, lineIndex) => (
+            <Text key={`${index}-${lineIndex}`} {...styles}>
+              {lineIndex === 0 ? `· ${line}` : `  ${line}`}
+            </Text>
+          ))}
+        </Box>
+      );
+    }
+
     if (log.type === 'step') {
       return (
         <Box key={index} flexDirection="column" paddingLeft={2}>
@@ -212,7 +227,7 @@ const LogPane: React.FC<LogPaneProps> = React.memo(({ verboseMode }) => {
     );
   };
 
-  const maxLogs = 100;
+  const maxLogs = 80;
   const visibleLogs = logs.length > maxLogs ? logs.slice(-maxLogs) : logs;
   return <Box flexDirection="column">{visibleLogs.map((log, index) => renderLogEntry(log, index)).filter(Boolean)}</Box>;
 });

package/src/experience-tracker.ts

@@ -188,7 +188,7 @@ export class ExperienceTracker {
     const updatedContent = `${newEntry}\n\n${content}`;
     this.writeExperienceFile(stateHash, updatedContent, data);
 
-    tag('substep').log(` Added ACTION to: ${stateHash}.md`);
+    tag('operation').log(`Added ACTION to: ${stateHash}.md`);
   }
 
   writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void {
@@ -218,7 +218,7 @@ export class ExperienceTracker {
     const updatedContent = `${body}\n${content}`;
     this.writeExperienceFile(stateHash, updatedContent, data);
 
-    tag('substep').log(`Added FLOW to: ${stateHash}.md`);
+    tag('operation').log(`Added FLOW to: ${stateHash}.md`);
   }
 
   getAllExperience(): ExperienceFile[] {

package/src/explorbot.ts

@@ -487,7 +487,7 @@ export class ExplorBot {
         return;
       }
 
-      tag('multiline').log(markdown);
+      tag('multiline').log(markdown, { maxLines: 22 });
 
       const filePath = this.agentSessionAnalyst().writeReport(markdown);
       tag('info').log(`Session report saved: ${relativeToCwd(filePath)}`);

package/src/reporter.ts

@@ -1,7 +1,7 @@
 import { join } from 'node:path';
 import { Client } from '@testomatio/reporter';
 import type { Step } from '@testomatio/reporter/types/types.js';
-import { ConfigParser, outputPath } from './config.js';
+import { outputPath } from './config.js';
 import type { ReporterConfig } from './config.js';
 import type { StateManager } from './state-manager.js';
 import { Stats } from './stats.js';
@@ -103,11 +103,13 @@ export class Reporter {
     }
 
     try {
-      this.client = new Client({ apiKey: process.env.TESTOMATIO || '', title: this.buildTitle() });
-      const timeoutMs = Number(process.env.TESTOMATIO_TIMEOUT_MS || '15000');
-      const timeoutPromise = new Promise<'timeout'>((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
+      const result = await withQuietReporterLogs(async () => {
+        this.client = new Client({ apiKey: process.env.TESTOMATIO || '', title: this.buildTitle() });
+        const timeoutMs = Number(process.env.TESTOMATIO_TIMEOUT_MS || '15000');
+        const timeoutPromise = new Promise<'timeout'>((resolve) => setTimeout(() => resolve('timeout'), timeoutMs));
 
-      const result = await Promise.race([this.client.createRun({ configuration: { exploratory: true } }).then(() => 'success' as const), timeoutPromise]);
+        return await Promise.race([this.client.createRun({ configuration: { exploratory: true } }).then(() => 'success' as const), timeoutPromise]);
+      });
 
       if (result === 'timeout') {
         debugLog('Reporter run creation timed out');
@@ -294,7 +296,9 @@ export class Reporter {
     }
 
     try {
-      await this.client.updateRunStatus('finished');
+      await withQuietReporterLogs(async () => {
+        await this.client.updateRunStatus('finished');
+      });
       this.isRunStarted = false;
       debugLog('Testomat.io run finished');
     } catch (error) {
@@ -340,3 +344,17 @@ export class Reporter {
     return;
   }
 }
+
+async function withQuietReporterLogs<T>(fn: () => Promise<T>): Promise<T> {
+  const previousLevel = process.env.TESTOMATIO_LOG_LEVEL;
+  process.env.TESTOMATIO_LOG_LEVEL = 'ERROR';
+  try {
+    return await fn();
+  } finally {
+    if (previousLevel === undefined) {
+      process.env.TESTOMATIO_LOG_LEVEL = undefined;
+    } else {
+      process.env.TESTOMATIO_LOG_LEVEL = previousLevel;
+    }
+  }
+}

package/src/utils/log-filters.ts

@@ -0,0 +1,26 @@
+export class RecentStepFilter {
+  private recentStepKeys = new Map<string, number>();
+
+  constructor(private ttlMs = 15000) {}
+
+  shouldSuppress(content: string, now = Date.now()): boolean {
+    const key = normalizeStepCommand(content);
+    if (!key) return false;
+
+    for (const [existingKey, timestamp] of this.recentStepKeys) {
+      if (now - timestamp > this.ttlMs) {
+        this.recentStepKeys.delete(existingKey);
+      }
+    }
+
+    if (this.recentStepKeys.has(key)) return true;
+    this.recentStepKeys.set(key, now);
+    return false;
+  }
+}
+
+function normalizeStepCommand(content: string): string | null {
+  const normalized = content.replace(/\s+/g, ' ').trim();
+  if (!normalized.startsWith('I.')) return null;
+  return normalized.toLowerCase();
+}

package/src/utils/logger.ts

@@ -8,9 +8,10 @@ import { marked } from 'marked';
 import stripAnsi from 'strip-ansi';
 import { ConfigParser } from '../config.js';
 import { Observability } from '../observability.ts';
+import { RecentStepFilter } from './log-filters.ts';
 import { parseMarkdownToTerminal } from './markdown-terminal.ts';
 
-export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'step' | 'multiline' | 'html' | 'input';
+export type LogType = 'info' | 'success' | 'error' | 'warning' | 'debug' | 'substep' | 'operation' | 'step' | 'multiline' | 'html' | 'input';
 
 export interface TaggedLogEntry {
   type: LogType;
@@ -18,6 +19,7 @@ export interface TaggedLogEntry {
   timestamp?: Date;
   originalArgs?: any[];
   namespace?: string;
+  maxLines?: number;
 }
 
 type LogEntry = TaggedLogEntry;
@@ -77,6 +79,7 @@ const debugFilter = new DebugFilter();
 class ConsoleDestination implements LogDestination {
   private verboseMode = false;
   private forceEnabled = false;
+  private recentSteps = new RecentStepFilter();
 
   isEnabled(): boolean {
     return this.forceEnabled || !process.env.INK_RUNNING;
@@ -93,6 +96,8 @@ class ConsoleDestination implements LogDestination {
   write(entry: TaggedLogEntry): void {
     if (entry.type === 'debug') return;
     if (entry.type === 'html') return;
+    if (entry.type === 'operation' && !this.verboseMode) return;
+    if (entry.type === 'step' && !this.verboseMode && this.recentSteps.shouldSuppress(entry.content)) return;
     let content = entry.content;
     if (entry.type === 'multiline') {
       const cleaned = stripAnsi(dedent(entry.content));
@@ -107,6 +112,8 @@ class ConsoleDestination implements LogDestination {
       content = chalk.yellow(content);
     } else if (entry.type === 'step') {
       content = chalk.gray(`   ${content}`);
+    } else if (entry.type === 'operation') {
+      content = chalk.gray(`   · ${content}`);
     } else if (entry.type === 'substep') {
       content = chalk.gray(`   > ${content}`);
     }
@@ -247,6 +254,7 @@ class ReactDestination implements LogDestination {
   }
 
   private shouldWrite(entry: TaggedLogEntry): boolean {
+    if (entry.type === 'operation' && !this.debugMode) return false;
     if (entry.type !== 'debug') return true;
     if (this.debugMode) return true;
     if (!entry.namespace) return true;
@@ -306,7 +314,7 @@ class CaptainDestination implements LogDestination {
 
   stopCapture(): string[] {
     this.capturing = false;
-    const logs = this.entries.filter((e) => e.type !== 'debug' && e.type !== 'html' && e.type !== 'multiline').map((e) => `[${e.type}] ${e.content}`);
+    const logs = this.entries.filter((e) => e.type !== 'debug' && e.type !== 'html' && e.type !== 'multiline' && e.type !== 'operation').map((e) => `[${e.type}] ${e.content}`);
     this.entries = [];
     return logs;
   }
@@ -432,6 +440,7 @@ class Logger {
       return;
     }
 
+    const options = this.extractLogOptions(type, args);
     let content = this.processArgs(args);
     if (type === 'step' && args[0]?.toCode) {
       content = args[0].toCode();
@@ -441,6 +450,7 @@ class Logger {
       content,
       timestamp: new Date(),
       originalArgs: args,
+      maxLines: options?.maxLines,
     };
 
     if (this.file.isEnabled()) this.file.write(entry);
@@ -480,6 +490,18 @@ class Logger {
   multiline(...args: any[]): void {
     this.log('multiline', ...args);
   }
+
+  private extractLogOptions(type: LogType, args: any[]): { maxLines?: number } | null {
+    if (type !== 'multiline') return null;
+    const last = args[args.length - 1];
+    if (!last || typeof last !== 'object' || Array.isArray(last)) return null;
+    if (!('maxLines' in last)) return null;
+
+    args.pop();
+    const maxLines = Number(last.maxLines);
+    if (!Number.isFinite(maxLines) || maxLines <= 0) return null;
+    return { maxLines };
+  }
 }
 
 const logger = Logger.getInstance();

package/src/utils/next-steps.ts

@@ -42,10 +42,5 @@ export function printNextSteps(sections: NextStepSection[]): void {
     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);
-    }
-  }
+  tag('multiline').log(blocks.join('\n\n'), { maxLines: 18 });
 }