Make sure visualizer src/lib is included

Author: alexzhang13

.gitignore

@@ -23,6 +23,7 @@ eggs/
 lib/
 lib64/
 !docs/src/lib/
+!visualizer/src/lib/
 parts/
 sdist/
 var/

visualizer/src/lib/parse-logs.ts

@@ -0,0 +1,181 @@
+import { RLMIteration, RLMLogFile, LogMetadata, RLMConfigMetadata, extractFinalAnswer } from './types';
+
+// Extract the context variable from code block locals
+export function extractContextVariable(iterations: RLMIteration[]): string | null {
+  for (const iter of iterations) {
+    for (const block of iter.code_blocks) {
+      if (block.result?.locals?.context) {
+        const ctx = block.result.locals.context;
+        if (typeof ctx === 'string') {
+          return ctx;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+// Default config when metadata is not present (backwards compatibility)
+function getDefaultConfig(): RLMConfigMetadata {
+  return {
+    root_model: null,
+    max_depth: null,
+    max_iterations: null,
+    backend: null,
+    backend_kwargs: null,
+    environment_type: null,
+    environment_kwargs: null,
+    other_backends: null,
+  };
+}
+
+export interface ParsedJSONL {
+  iterations: RLMIteration[];
+  config: RLMConfigMetadata;
+}
+
+export function parseJSONL(content: string): ParsedJSONL {
+  const lines = content.trim().split('\n').filter(line => line.trim());
+  const iterations: RLMIteration[] = [];
+  let config: RLMConfigMetadata = getDefaultConfig();
+  
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      
+      // Check if this is a metadata entry
+      if (parsed.type === 'metadata') {
+        config = {
+          root_model: parsed.root_model ?? null,
+          max_depth: parsed.max_depth ?? null,
+          max_iterations: parsed.max_iterations ?? null,
+          backend: parsed.backend ?? null,
+          backend_kwargs: parsed.backend_kwargs ?? null,
+          environment_type: parsed.environment_type ?? null,
+          environment_kwargs: parsed.environment_kwargs ?? null,
+          other_backends: parsed.other_backends ?? null,
+        };
+      } else {
+        // This is an iteration entry
+        iterations.push(parsed as RLMIteration);
+      }
+    } catch (e) {
+      console.error('Failed to parse line:', line, e);
+    }
+  }
+  
+  return { iterations, config };
+}
+
+export function extractContextQuestion(iterations: RLMIteration[]): string {
+  if (iterations.length === 0) return 'No context found';
+  
+  const firstIteration = iterations[0];
+  const prompt = firstIteration.prompt;
+  
+  // Look for user message that contains the actual question
+  for (const msg of prompt) {
+    if (msg.role === 'user' && msg.content) {
+      // Try to extract quoted query
+      const queryMatch = msg.content.match(/original query: "([^"]+)"/);
+      if (queryMatch) {
+        return queryMatch[1];
+      }
+      
+      // Check if it contains the actual query pattern
+      if (msg.content.includes('answer the prompt')) {
+        continue;
+      }
+      
+      // Take first substantial user message
+      if (msg.content.length > 50 && msg.content.length < 500) {
+        return msg.content.slice(0, 200) + (msg.content.length > 200 ? '...' : '');
+      }
+    }
+  }
+  
+  // Fallback: look in system prompt for context info
+  const systemMsg = prompt.find(m => m.role === 'system');
+  if (systemMsg?.content) {
+    const contextMatch = systemMsg.content.match(/context variable.*?:(.*?)(?:\n|$)/i);
+    if (contextMatch) {
+      return contextMatch[1].trim().slice(0, 200);
+    }
+  }
+  
+  // Check code block output for actual context
+  for (const iter of iterations) {
+    for (const block of iter.code_blocks) {
+      if (block.result?.locals?.context) {
+        const ctx = block.result.locals.context;
+        if (typeof ctx === 'string' && ctx.length < 500) {
+          return ctx;
+        }
+      }
+    }
+  }
+  
+  return 'Context available in REPL environment';
+}
+
+export function computeMetadata(iterations: RLMIteration[]): LogMetadata {
+  let totalCodeBlocks = 0;
+  let totalSubLMCalls = 0;
+  let totalExecutionTime = 0;
+  let hasErrors = false;
+  let finalAnswer: string | null = null;
+  
+  for (const iter of iterations) {
+    totalCodeBlocks += iter.code_blocks.length;
+    
+    // Use iteration_time if available, otherwise sum code block times
+    if (iter.iteration_time != null) {
+      totalExecutionTime += iter.iteration_time;
+    } else {
+      for (const block of iter.code_blocks) {
+        if (block.result) {
+          totalExecutionTime += block.result.execution_time || 0;
+        }
+      }
+    }
+    
+    for (const block of iter.code_blocks) {
+      if (block.result) {
+        if (block.result.stderr) {
+          hasErrors = true;
+        }
+        if (block.result.rlm_calls) {
+          totalSubLMCalls += block.result.rlm_calls.length;
+        }
+      }
+    }
+    
+    if (iter.final_answer) {
+      finalAnswer = extractFinalAnswer(iter.final_answer);
+    }
+  }
+  
+  return {
+    totalIterations: iterations.length,
+    totalCodeBlocks,
+    totalSubLMCalls,
+    contextQuestion: extractContextQuestion(iterations),
+    finalAnswer,
+    totalExecutionTime,
+    hasErrors,
+  };
+}
+
+export function parseLogFile(fileName: string, content: string): RLMLogFile {
+  const { iterations, config } = parseJSONL(content);
+  const metadata = computeMetadata(iterations);
+  
+  return {
+    fileName,
+    filePath: fileName,
+    iterations,
+    metadata,
+    config,
+  };
+}
+

visualizer/src/lib/types.ts

@@ -0,0 +1,72 @@
+// Types matching the RLM log format
+
+export interface RLMChatCompletion {
+  prompt: string | Record<string, unknown>;
+  response: string;
+  prompt_tokens: number;
+  completion_tokens: number;
+  execution_time: number;
+}
+
+export interface REPLResult {
+  stdout: string;
+  stderr: string;
+  locals: Record<string, unknown>;
+  execution_time: number;
+  rlm_calls: RLMChatCompletion[];
+}
+
+export interface CodeBlock {
+  code: string;
+  result: REPLResult;
+}
+
+export interface RLMIteration {
+  type?: string;
+  iteration: number;
+  timestamp: string;
+  prompt: Array<{ role: string; content: string }>;
+  response: string;
+  code_blocks: CodeBlock[];
+  final_answer: string | [string, string] | null;
+  iteration_time: number | null;
+}
+
+// Metadata saved at the start of a log file about RLM configuration
+export interface RLMConfigMetadata {
+  root_model: string | null;
+  max_depth: number | null;
+  max_iterations: number | null;
+  backend: string | null;
+  backend_kwargs: Record<string, unknown> | null;
+  environment_type: string | null;
+  environment_kwargs: Record<string, unknown> | null;
+  other_backends: string[] | null;
+}
+
+export interface RLMLogFile {
+  fileName: string;
+  filePath: string;
+  iterations: RLMIteration[];
+  metadata: LogMetadata;
+  config: RLMConfigMetadata;
+}
+
+export interface LogMetadata {
+  totalIterations: number;
+  totalCodeBlocks: number;
+  totalSubLMCalls: number;
+  contextQuestion: string;
+  finalAnswer: string | null;
+  totalExecutionTime: number;
+  hasErrors: boolean;
+}
+
+export function extractFinalAnswer(answer: string | [string, string] | null): string | null {
+  if (!answer) return null;
+  if (Array.isArray(answer)) {
+    return answer[1];
+  }
+  return answer;
+}
+

visualizer/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}