explorbot 0.1.25 → 0.1.26

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 });
 }