@litmers/cursorflow-orchestrator 0.1.20 → 0.1.28

package/src/utils/lock.ts

@@ -0,0 +1,346 @@
+/**
+ * Enhanced file-based locking with async support and stale lock detection
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { safeJoin } from './path';
+
+export interface LockInfo {
+  pid: number;
+  timestamp: number;
+  operation: string;
+  hostname?: string;
+}
+
+export interface LockOptions {
+  /** Maximum time to wait for lock in milliseconds */
+  timeoutMs?: number;
+  /** Delay between retry attempts in milliseconds */
+  retryDelayMs?: number;
+  /** Lock is considered stale after this many milliseconds */
+  staleTimeoutMs?: number;
+  /** Description of the operation for logging */
+  operation?: string;
+}
+
+export const DEFAULT_LOCK_OPTIONS: Required<LockOptions> = {
+  timeoutMs: 30000,
+  retryDelayMs: 100,
+  staleTimeoutMs: 60000,
+  operation: 'unknown',
+};
+
+/**
+ * Check if a process is still running
+ */
+export function isProcessRunning(pid: number): boolean {
+  try {
+    // Sending signal 0 checks if process exists without actually signaling it
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the lock directory for a given base path
+ */
+export function getLockDir(basePath: string): string {
+  return safeJoin(basePath, '_cursorflow', 'locks');
+}
+
+/**
+ * Ensure lock directory exists
+ */
+export function ensureLockDir(basePath: string): string {
+  const lockDir = getLockDir(basePath);
+  if (!fs.existsSync(lockDir)) {
+    fs.mkdirSync(lockDir, { recursive: true });
+  }
+  return lockDir;
+}
+
+/**
+ * Read lock file info
+ */
+export function readLockInfo(lockFile: string): LockInfo | null {
+  try {
+    if (!fs.existsSync(lockFile)) {
+      return null;
+    }
+    const content = fs.readFileSync(lockFile, 'utf8');
+    return JSON.parse(content) as LockInfo;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a lock is stale
+ */
+export function isLockStale(lockInfo: LockInfo, staleTimeoutMs: number): boolean {
+  // Check if process is dead
+  if (!isProcessRunning(lockInfo.pid)) {
+    return true;
+  }
+
+  // Check if lock has expired
+  if (Date.now() - lockInfo.timestamp > staleTimeoutMs) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Try to acquire a lock synchronously (for backward compatibility)
+ */
+export function tryAcquireLockSync(lockFile: string, options: LockOptions = {}): boolean {
+  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
+  
+  // Check for existing lock
+  const existingLock = readLockInfo(lockFile);
+  if (existingLock) {
+    if (!isLockStale(existingLock, opts.staleTimeoutMs)) {
+      return false;
+    }
+    // Stale lock - remove it
+    try {
+      fs.unlinkSync(lockFile);
+    } catch {
+      return false;
+    }
+  }
+
+  // Try to create lock atomically
+  const lockInfo: LockInfo = {
+    pid: process.pid,
+    timestamp: Date.now(),
+    operation: opts.operation,
+    hostname: require('os').hostname(),
+  };
+
+  try {
+    fs.writeFileSync(lockFile, JSON.stringify(lockInfo, null, 2), { flag: 'wx' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Release a lock synchronously
+ */
+export function releaseLockSync(lockFile: string): void {
+  try {
+    const lockInfo = readLockInfo(lockFile);
+    // Only release if we own the lock
+    if (lockInfo && lockInfo.pid === process.pid) {
+      fs.unlinkSync(lockFile);
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Acquire a lock with async waiting
+ */
+export async function acquireLock(lockFile: string, options: LockOptions = {}): Promise<boolean> {
+  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < opts.timeoutMs) {
+    if (tryAcquireLockSync(lockFile, opts)) {
+      return true;
+    }
+
+    // Wait before retrying with jitter
+    const jitter = Math.random() * opts.retryDelayMs * 0.5;
+    await new Promise(resolve => setTimeout(resolve, opts.retryDelayMs + jitter));
+  }
+
+  return false;
+}
+
+/**
+ * Release a lock
+ */
+export async function releaseLock(lockFile: string): Promise<void> {
+  releaseLockSync(lockFile);
+}
+
+/**
+ * Execute a function while holding a lock
+ */
+export async function withLock<T>(
+  lockFile: string,
+  fn: () => Promise<T>,
+  options: LockOptions = {}
+): Promise<T> {
+  const acquired = await acquireLock(lockFile, options);
+  if (!acquired) {
+    throw new Error(`Failed to acquire lock: ${lockFile} (timeout: ${options.timeoutMs || DEFAULT_LOCK_OPTIONS.timeoutMs}ms)`);
+  }
+
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lockFile);
+  }
+}
+
+/**
+ * Execute a synchronous function while holding a lock
+ */
+export function withLockSync<T>(
+  lockFile: string,
+  fn: () => T,
+  options: LockOptions = {}
+): T {
+  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
+  const startTime = Date.now();
+
+  // Busy wait for lock (synchronous)
+  while (Date.now() - startTime < opts.timeoutMs) {
+    if (tryAcquireLockSync(lockFile, opts)) {
+      try {
+        return fn();
+      } finally {
+        releaseLockSync(lockFile);
+      }
+    }
+
+    // Sync sleep
+    const end = Date.now() + opts.retryDelayMs;
+    while (Date.now() < end) { /* busy wait */ }
+  }
+
+  throw new Error(`Failed to acquire lock: ${lockFile} (timeout: ${opts.timeoutMs}ms)`);
+}
+
+/**
+ * Clean up stale locks in a directory
+ */
+export function cleanStaleLocks(lockDir: string, staleTimeoutMs: number = DEFAULT_LOCK_OPTIONS.staleTimeoutMs): number {
+  if (!fs.existsSync(lockDir)) {
+    return 0;
+  }
+
+  let cleaned = 0;
+  const files = fs.readdirSync(lockDir);
+
+  for (const file of files) {
+    if (!file.endsWith('.lock')) continue;
+
+    const lockFile = safeJoin(lockDir, file);
+    const lockInfo = readLockInfo(lockFile);
+
+    if (lockInfo && isLockStale(lockInfo, staleTimeoutMs)) {
+      try {
+        fs.unlinkSync(lockFile);
+        cleaned++;
+      } catch {
+        // Ignore
+      }
+    }
+  }
+
+  return cleaned;
+}
+
+/**
+ * Get status of all locks in a directory
+ */
+export function getLockStatus(lockDir: string): Array<{ file: string; info: LockInfo; stale: boolean }> {
+  if (!fs.existsSync(lockDir)) {
+    return [];
+  }
+
+  const result: Array<{ file: string; info: LockInfo; stale: boolean }> = [];
+  const files = fs.readdirSync(lockDir);
+
+  for (const file of files) {
+    if (!file.endsWith('.lock')) continue;
+
+    const lockFile = safeJoin(lockDir, file);
+    const lockInfo = readLockInfo(lockFile);
+
+    if (lockInfo) {
+      result.push({
+        file,
+        info: lockInfo,
+        stale: isLockStale(lockInfo, DEFAULT_LOCK_OPTIONS.staleTimeoutMs),
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Named lock manager for managing multiple locks
+ */
+export class LockManager {
+  private readonly basePath: string;
+  private readonly heldLocks: Set<string> = new Set();
+
+  constructor(basePath: string) {
+    this.basePath = basePath;
+    ensureLockDir(basePath);
+
+    // Register cleanup on process exit
+    process.on('exit', () => this.releaseAll());
+    process.on('SIGINT', () => {
+      this.releaseAll();
+      process.exit(130);
+    });
+    process.on('SIGTERM', () => {
+      this.releaseAll();
+      process.exit(143);
+    });
+  }
+
+  private getLockPath(name: string): string {
+    return safeJoin(getLockDir(this.basePath), `${name}.lock`);
+  }
+
+  async acquire(name: string, options: LockOptions = {}): Promise<boolean> {
+    const lockPath = this.getLockPath(name);
+    const acquired = await acquireLock(lockPath, options);
+    if (acquired) {
+      this.heldLocks.add(name);
+    }
+    return acquired;
+  }
+
+  async release(name: string): Promise<void> {
+    const lockPath = this.getLockPath(name);
+    await releaseLock(lockPath);
+    this.heldLocks.delete(name);
+  }
+
+  releaseAll(): void {
+    for (const name of this.heldLocks) {
+      const lockPath = this.getLockPath(name);
+      releaseLockSync(lockPath);
+    }
+    this.heldLocks.clear();
+  }
+
+  async withLock<T>(name: string, fn: () => Promise<T>, options: LockOptions = {}): Promise<T> {
+    const lockPath = this.getLockPath(name);
+    return withLock(lockPath, fn, options);
+  }
+
+  cleanStale(staleTimeoutMs?: number): number {
+    return cleanStaleLocks(getLockDir(this.basePath), staleTimeoutMs);
+  }
+
+  getStatus(): Array<{ file: string; info: LockInfo; stale: boolean }> {
+    return getLockStatus(getLockDir(this.basePath));
+  }
+}
+

package/src/utils/log-buffer.ts

@@ -0,0 +1,28 @@
+/**
+ * LogBufferService - Scrollable log buffer for TUI monitor
+ * 
+ * This file is kept for backward compatibility.
+ * New code should import from '../services/logging/buffer' directly.
+ */
+
+// Re-export everything from the new services/logging/buffer module
+export { 
+  LogBufferService, 
+  createLogBuffer,
+  type LogBufferOptions,
+  type LogFilter,
+  type LogBufferState,
+} from '../services/logging/buffer';
+
+// Re-export types from types/logging for backward compatibility
+export type { JsonLogEntry, BufferedLogEntry } from '../types/logging';
+
+/**
+ * Log viewport interface for backward compatibility
+ */
+export interface LogViewport {
+  entries: import('../types/logging').BufferedLogEntry[];
+  totalCount: number;
+  offset: number;
+  visibleCount: number;
+}

package/src/utils/log-constants.ts

@@ -0,0 +1,26 @@
+/**
+ * Shared log constants to avoid circular dependencies
+ */
+
+export const COLORS = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  gray: '\x1b[90m',
+  bold: '\x1b[1m',
+  white: '\x1b[37m',
+};
+
+export enum LogLevel {
+  error = 0,
+  warn = 1,
+  info = 2,
+  success = 2,
+  progress = 2,
+  debug = 3,
+}
+

package/src/utils/log-formatter.ts

@@ -1,10 +1,33 @@
 /**
  * Utility for formatting log messages for console display
+ * 
+ * Format: [HH:MM:SS] [lane-task] ICON TYPE content
+ * 
+ * Rules:
+ * - Box format only for: user, assistant, system, result
+ * - Compact format for: tool, tool_result, thinking (gray/dim)
+ * - Tool names simplified: ShellToolCall → Shell
+ * - Lane labels max 16 chars: [01-types-tests]
  */
 
-import * as logger from './logger';
+import { COLORS } from './log-constants';
 import { ParsedMessage, stripAnsi } from './enhanced-logger';
 
+// Types that should use box format
+const BOX_TYPES = new Set(['user', 'assistant', 'system', 'result']);
+
+/**
+ * Simplify tool names (ShellToolCall → Shell, etc.)
+ */
+function simplifyToolName(name: string): string {
+  // Remove common suffixes
+  return name
+    .replace(/ToolCall$/i, '')
+    .replace(/Tool$/i, '')
+    .replace(/^run_terminal_cmd$/i, 'shell')
+    .replace(/^search_replace$/i, 'edit');
+}
+
 /**
  * Format a single parsed message into a human-readable string (compact or multi-line)
  */
@@ -14,40 +37,75 @@ export function formatMessageForConsole(
     includeTimestamp?: boolean; 
     laneLabel?: string;
     compact?: boolean;
+    context?: string;
   } = {}
 ): string {
-  const { includeTimestamp = true, laneLabel = '', compact = false } = options;
+  const { includeTimestamp = true, laneLabel = '', compact = false, context = '' } = options;
   const ts = includeTimestamp ? new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false }) : '';
-  const tsPrefix = ts ? `${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ` : '';
-  const labelPrefix = laneLabel ? `${logger.COLORS.magenta}${laneLabel.padEnd(12)}${logger.COLORS.reset} ` : '';
+  const tsPrefix = ts ? `${COLORS.gray}[${ts}]${COLORS.reset} ` : '';
+  
+  // Handle context (e.g. from logger.info) - max 16 chars
+  const effectiveLaneLabel = laneLabel || (context ? `[${context}]` : '');
+  const truncatedLabel = effectiveLaneLabel.length > 16 
+    ? effectiveLaneLabel.substring(0, 16) 
+    : effectiveLaneLabel;
+  const labelPrefix = truncatedLabel ? `${COLORS.magenta}${truncatedLabel.padEnd(16)}${COLORS.reset} ` : '';
   
   let typePrefix = '';
   let content = msg.content;
   
+  // Determine if we should use box format
+  // Box format only for: user, assistant, system, result (and only when not compact)
+  const useBox = !compact && BOX_TYPES.has(msg.type);
+
+  // Clean up wrapped prompts for user messages to hide internal instructions
+  if (msg.type === 'user') {
+    const contextMarker = '### 🛠 Environment & Context';
+    const instructionsMarker = '### 📝 Final Instructions';
+    
+    if (content.includes(contextMarker)) {
+      const parts = content.split('---\n');
+      if (parts.length >= 3) {
+        content = parts[1]!.trim();
+      } else {
+        content = content.split(contextMarker).pop() || content;
+        content = content.split(instructionsMarker)[0] || content;
+        content = content.replace(/^.*---\n/s, '').trim();
+      }
+    }
+  }
+  
+  // For thinking: collapse multiple newlines into single space
+  if (msg.type === 'thinking') {
+    content = content.replace(/\n\s*\n/g, ' ').replace(/\n/g, ' ').trim();
+  }
+  
   switch (msg.type) {
     case 'user':
-      typePrefix = `${logger.COLORS.cyan}🧑 USER${logger.COLORS.reset}`;
-      if (compact) content = content.replace(/\n/g, ' ').substring(0, 100) + (content.length > 100 ? '...' : '');
+      typePrefix = `${COLORS.cyan}🧑 USER${COLORS.reset}`;
+      if (!useBox) content = content.replace(/\n/g, ' ').substring(0, 100) + (content.length > 100 ? '...' : '');
       break;
     case 'assistant':
-      typePrefix = `${logger.COLORS.green}🤖 ASST${logger.COLORS.reset}`;
-      if (compact) content = content.replace(/\n/g, ' ').substring(0, 100) + (content.length > 100 ? '...' : '');
+      typePrefix = `${COLORS.green}🤖 ASST${COLORS.reset}`;
+      if (!useBox) content = content.replace(/\n/g, ' ').substring(0, 100) + (content.length > 100 ? '...' : '');
       break;
     case 'tool':
-      typePrefix = `${logger.COLORS.yellow}🔧 TOOL${logger.COLORS.reset}`;
+      // Tool calls are always compact and gray
+      typePrefix = `${COLORS.gray}🔧 TOOL${COLORS.reset}`;
       const toolMatch = content.match(/\[Tool: ([^\]]+)\] (.*)/);
       if (toolMatch) {
-        const [, name, args] = toolMatch;
+        const [, rawName, args] = toolMatch;
+        const name = simplifyToolName(rawName!);
         try {
           const parsedArgs = JSON.parse(args!);
           let argStr = '';
-          if (name === 'read_file' && parsedArgs.target_file) {
+          if (rawName === 'read_file' && parsedArgs.target_file) {
             argStr = parsedArgs.target_file;
-          } else if (name === 'run_terminal_cmd' && parsedArgs.command) {
+          } else if (rawName === 'run_terminal_cmd' && parsedArgs.command) {
             argStr = parsedArgs.command;
-          } else if (name === 'write' && parsedArgs.file_path) {
+          } else if (rawName === 'write' && parsedArgs.file_path) {
             argStr = parsedArgs.file_path;
-          } else if (name === 'search_replace' && parsedArgs.file_path) {
+          } else if (rawName === 'search_replace' && parsedArgs.file_path) {
             argStr = parsedArgs.file_path;
           } else {
             const keys = Object.keys(parsedArgs);
@@ -55,46 +113,71 @@ export function formatMessageForConsole(
               argStr = String(parsedArgs[keys[0]]).substring(0, 50);
             }
           }
-          content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}(${argStr})`;
+          content = `${COLORS.gray}${name}${COLORS.reset}(${COLORS.gray}${argStr}${COLORS.reset})`;
         } catch {
-          content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}: ${args}`;
+          content = `${COLORS.gray}${name}${COLORS.reset}: ${args}`;
         }
       }
       break;
     case 'tool_result':
-      typePrefix = `${logger.COLORS.gray}📄 RESL${logger.COLORS.reset}`;
+      // Tool results are always compact and gray
+      typePrefix = `${COLORS.gray}📄 RESL${COLORS.reset}`;
       const resMatch = content.match(/\[Tool Result: ([^\]]+)\]/);
-      content = resMatch ? `${resMatch[1]} OK` : 'result';
+      if (resMatch) {
+        const simpleName = simplifyToolName(resMatch[1]!);
+        content = `${COLORS.gray}${simpleName} OK${COLORS.reset}`;
+      } else {
+        content = `${COLORS.gray}result${COLORS.reset}`;
+      }
       break;
     case 'result':
-      typePrefix = `${logger.COLORS.green}✅ DONE${logger.COLORS.reset}`;
+    case 'success':
+      typePrefix = `${COLORS.green}✅ DONE${COLORS.reset}`;
       break;
     case 'system':
-      typePrefix = `${logger.COLORS.gray}⚙️  SYS${logger.COLORS.reset}`;
+      typePrefix = `${COLORS.gray}⚙️ SYS${COLORS.reset}`;
       break;
     case 'thinking':
-      typePrefix = `${logger.COLORS.gray}🤔 THNK${logger.COLORS.reset}`;
-      if (compact) content = content.replace(/\n/g, ' ').substring(0, 100) + (content.length > 100 ? '...' : '');
+      // Thinking is always compact and gray
+      typePrefix = `${COLORS.gray}🤔 THNK${COLORS.reset}`;
+      content = `${COLORS.gray}${content.substring(0, 100)}${content.length > 100 ? '...' : ''}${COLORS.reset}`;
+      break;
+    case 'info':
+      typePrefix = `${COLORS.cyan}ℹ️ INFO${COLORS.reset}`;
+      break;
+    case 'warn':
+      typePrefix = `${COLORS.yellow}⚠️ WARN${COLORS.reset}`;
+      break;
+    case 'error':
+      typePrefix = `${COLORS.red}❌ ERR${COLORS.reset}`;
       break;
   }
   
   if (!typePrefix) return `${tsPrefix}${labelPrefix}${content}`;
 
-  if (compact) {
-    return `${tsPrefix}${labelPrefix}${typePrefix} ${content}`;
+  // Compact format (single line)
+  if (!useBox) {
+    return `${tsPrefix}${labelPrefix}${typePrefix.padEnd(12)} ${content}`;
   }
 
-  // Multi-line box format (as seen in orchestrator)
+  // Multi-line box format (only for user, assistant, system, result)
+  // Emoji width is 2, so we need to account for that in indent calculation
   const lines = content.split('\n');
   const fullPrefix = `${tsPrefix}${labelPrefix}`;
-  const header = `${typePrefix} ┌${'─'.repeat(60)}`;
+  const strippedPrefix = stripAnsi(typePrefix);
+  // Count emojis (they take 2 terminal columns but 1-2 chars in string)
+  const emojiCount = (strippedPrefix.match(/[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2300}-\u{23FF}]|[\u{2B50}-\u{2B55}]|[\u{231A}-\u{231B}]|[\u{23E9}-\u{23F3}]|[\u{23F8}-\u{23FA}]|✅|❌|⚙️|ℹ️|⚠️|🔧|📄|🤔|🧑|🤖/gu) || []).length;
+  const visualWidth = strippedPrefix.length + emojiCount; // emoji adds 1 extra width
+  
+  const boxWidth = 60;
+  const header = `${typePrefix}┌${'─'.repeat(boxWidth)}`;
   let result = `${fullPrefix}${header}\n`;
   
-  const indent = ' '.repeat(stripAnsi(typePrefix).length);
+  const indent = ' '.repeat(visualWidth);
   for (const line of lines) {
-    result += `${fullPrefix}${indent} │ ${line}\n`;
+    result += `${fullPrefix}${indent}│ ${line}\n`;
   }
-  result += `${fullPrefix}${indent} └${'─'.repeat(60)}`;
+  result += `${fullPrefix}${indent}└${'─'.repeat(boxWidth)}`;
   
   return result;
 }
@@ -113,8 +196,8 @@ export function formatPotentialJsonMessage(message: string): string {
     if (!json.type) return message;
     
     // Convert JSON to a ParsedMessage-like structure for formatting
-    let content = trimmed;
-    let type = 'system';
+    let content: string;
+    let type: string;
     
     if (json.type === 'thinking' && json.text) {
       content = json.text;
@@ -132,13 +215,14 @@ export function formatPotentialJsonMessage(message: string): string {
         .join('');
       type = 'user';
     } else if (json.type === 'tool_call' && json.subtype === 'started') {
-      const toolName = Object.keys(json.tool_call)[0] || 'unknown';
-      const args = json.tool_call[toolName]?.args || {};
-      content = `[Tool: ${toolName}] ${JSON.stringify(args)}`;
+      const rawToolName = Object.keys(json.tool_call)[0] || 'unknown';
+      const args = json.tool_call[rawToolName]?.args || {};
+      // Tool name will be simplified in formatMessageForConsole
+      content = `[Tool: ${rawToolName}] ${JSON.stringify(args)}`;
       type = 'tool';
     } else if (json.type === 'tool_call' && json.subtype === 'completed') {
-      const toolName = Object.keys(json.tool_call)[0] || 'unknown';
-      content = `[Tool Result: ${toolName}]`;
+      const rawToolName = Object.keys(json.tool_call)[0] || 'unknown';
+      content = `[Tool Result: ${rawToolName}]`;
       type = 'tool_result';
     } else if (json.type === 'result') {
       content = json.result || 'Task completed';
@@ -159,4 +243,3 @@ export function formatPotentialJsonMessage(message: string): string {
     return message;
   }
 }
-

package/src/utils/log-service.ts

@@ -0,0 +1,49 @@
+/**
+ * Log Service - Helpers for log processing and filtering
+ */
+
+import { JsonLogEntry } from './enhanced-logger';
+import { LogImportance } from './types';
+
+export interface MergedLogEntry extends JsonLogEntry {
+  laneName: string;
+  laneColor: string;
+}
+
+export class LogService {
+  /**
+   * Determine importance level of a log entry
+   */
+  static getLogImportance(entry: JsonLogEntry): LogImportance {
+    if (entry.level === 'error') return LogImportance.CRITICAL;
+    if (entry.level === 'stderr') return LogImportance.HIGH;
+    
+    const msg = (entry.message || '').toLowerCase();
+    if (msg.includes('error') || msg.includes('fail')) return LogImportance.HIGH;
+    if (msg.includes('warn')) return LogImportance.MEDIUM;
+    if (msg.includes('success') || msg.includes('done') || msg.includes('completed')) return LogImportance.LOW;
+    
+    if (entry.level === 'debug') return LogImportance.DEBUG;
+    return LogImportance.INFO;
+  }
+
+  /**
+   * Check if an entry meets the minimum importance level
+   */
+  static meetsImportanceLevel(entry: JsonLogEntry, minLevel: LogImportance): boolean {
+    const entryLevel = this.getLogImportance(entry);
+    const levels = [
+      LogImportance.DEBUG,
+      LogImportance.INFO,
+      LogImportance.LOW,
+      LogImportance.MEDIUM,
+      LogImportance.HIGH,
+      LogImportance.CRITICAL
+    ];
+    
+    const entryIdx = levels.indexOf(entryLevel);
+    const minIdx = levels.indexOf(minLevel);
+    
+    return entryIdx >= minIdx;
+  }
+}