feat: implement t-rWclFp3vN

2 files changed, 102 insertions, 128 deletions

diff --git a/Omni/Agent/Log.hs b/Omni/Agent/Log.hs
index 28b39ec..99b40ae 100644
--- a/Omni/Agent/Log.hs
+++ b/Omni/Agent/Log.hs
@@ -17,6 +17,17 @@ import qualified Data.ByteString.Lazy as BL
 import qualified Data.Text.Encoding as TextEnc
 import qualified Data.Vector as V
 
+-- | Parsed log entry
+data LogEntry = LogEntry
+  { leMessage :: Maybe Text,
+    leLevel :: Maybe Text,
+    leToolName :: Maybe Text,
+    leBatches :: Maybe [[Text]],
+    leMethod :: Maybe Text,
+    lePath :: Maybe Text
+  }
+  deriving (Show, Eq)
+
 -- | Status of the agent for the UI
 data Status = Status
   { statusWorker :: Text,
@@ -67,72 +78,85 @@ updateActivity msg = update (\s -> s {statusActivity = msg})
 -- | Process a log line from the agent and update status if relevant
 processLogLine :: Text -> IO ()
 processLogLine line = do
+  let entry = parseLine line
+  case entry >>= formatLogEntry of
+    Just msg -> updateActivity msg
+    Nothing -> pure ()
+
+-- | Parse a JSON log line into a LogEntry
+parseLine :: Text -> Maybe LogEntry
+parseLine line = do
   let lbs = BL.fromStrict (TextEnc.encodeUtf8 line)
-  case decode lbs of
-    Just (Object obj) -> do
-      let message =
-            case KM.lookup "message" obj of
-              Just (String m) -> Just m
-              _ -> Nothing
-
-      let toolName =
-            case KM.lookup "toolName" obj of
-              Just (String t) -> Just t
-              _ -> Nothing
-
-      let level =
-            case KM.lookup "level" obj of
-              Just (String l) -> Just l
-              _ -> Nothing
-
-      case message of
-        Just "executing 1 tools in 1 batch(es)" -> do
-          let batchTool =
-                case KM.lookup "batches" obj of
-                  Just (Array b) ->
-                    case V.toList b of
-                      (Array b0 : _) ->
-                        case V.toList b0 of
-                          (String t : _) -> Just t
-                          _ -> Nothing
-                      _ -> Nothing
-                  _ -> Nothing
-          updateActivity ("THOUGHT: Planning tool execution (" <> fromMaybe "unknown" batchTool <> ")")
-
-        Just "Tool Bash permitted - action: allow" ->
-          updateActivity "TOOL: Bash command executed"
-
-        Just msg | toolName /= Nothing && msg == "Processing tool completion for ledger" ->
-          updateActivity ("TOOL: " <> fromMaybe "unknown" toolName <> " completed")
-
-        Just "ide-fs" -> do
-          let method =
-                case KM.lookup "method" obj of
-                  Just (String m) -> Just m
+  obj <- decode lbs
+  case obj of
+    Object o ->
+      Just
+        LogEntry
+          { leMessage = getString "message" o,
+            leLevel = getString "level" o,
+            leToolName = getString "toolName" o,
+            leBatches = getBatches o,
+            leMethod = getString "method" o,
+            lePath = getString "path" o
+          }
+    _ -> Nothing
+  where
+    getString k o =
+      case KM.lookup k o of
+        Just (String s) -> Just s
+        _ -> Nothing
+
+    getBatches o =
+      case KM.lookup "batches" o of
+        Just (Array b) ->
+          Just <|
+            mapMaybe
+              ( \case
+                  Array b0 ->
+                    Just <|
+                      mapMaybe
+                        ( \case
+                            String s -> Just s
+                            _ -> Nothing
+                        )
+                        (V.toList b0)
                   _ -> Nothing
-          case method of
-            Just "readFile" -> do
-              let path =
-                    case KM.lookup "path" obj of
-                      Just (String p) -> Just p
-                      _ -> Nothing
-              case path of
-                Just p -> updateActivity ("READ: " <> p)
-                Nothing -> pure ()
-            _ -> pure ()
-
-        Just "System prompt build complete (no changes)" ->
-          updateActivity "THINKING..."
-
-        Just "System prompt build complete (first build)" ->
-          updateActivity "STARTING new task context"
-
-        Just msg | level == Just "error" ->
-          updateActivity ("ERROR: " <> msg)
-
-        _ -> pure ()
-
-    _ -> pure ()
+              )
+              (V.toList b)
+        _ -> Nothing
+
+-- | Format a log entry into a user-friendly status message (NO EMOJIS)
+formatLogEntry :: LogEntry -> Maybe Text
+formatLogEntry LogEntry {..} =
+  case leMessage of
+    Just "executing 1 tools in 1 batch(es)" -> do
+      let tools = fromMaybe [] leBatches
+      let firstTool = case tools of
+            ((t : _) : _) -> t
+            _ -> "unknown"
+      Just ("THOUGHT: Planning tool execution (" <> firstTool <> ")")
+    
+    Just "Tool Bash permitted - action: allow" ->
+      Just "TOOL: Bash command executed"
+
+    Just "Processing tool completion for ledger" | isJust leToolName ->
+      Just ("TOOL: " <> fromMaybe "unknown" leToolName <> " completed")
+
+    Just "ide-fs" | leMethod == Just "readFile" ->
+      case lePath of
+        Just p -> Just ("READ: " <> p)
+        _ -> Nothing
+
+    Just "System prompt build complete (no changes)" ->
+      Just "THINKING..."
+
+    Just "System prompt build complete (first build)" ->
+      Just "STARTING new task context"
+
+    Just msg | leLevel == Just "error" ->
+      Just ("ERROR: " <> msg)
+
+    _ -> Nothing
 
 -- | Log a scrolling message (appears above status bars)
 log :: Text -> IO ()
diff --git a/Omni/Agent/LogTest.hs b/Omni/Agent/LogTest.hs
index 518147e..97b558d 100644
--- a/Omni/Agent/LogTest.hs
+++ b/Omni/Agent/LogTest.hs
@@ -5,7 +5,6 @@
 module Omni.Agent.LogTest where
 
 import Alpha
-import qualified Data.Set as Set
 import Omni.Agent.Log
 import qualified Omni.Test as Test
 
@@ -17,9 +16,7 @@ tests =
   Test.group
     "Omni.Agent.Log"
     [ Test.unit "Parse LogEntry" testParse,
-      Test.unit "Format LogEntry" testFormat,
-      Test.unit "Update Status" testUpdateStatus,
-      Test.unit "Render Status" testRenderStatus
+      Test.unit "Format LogEntry" testFormat
     ]
 
 testParse :: IO ()
@@ -27,13 +24,12 @@ testParse = do
   let json = "{\"message\": \"executing 1 tools in 1 batch(es)\", \"batches\": [[\"grep\"]]}"
   let expected =
         LogEntry
-          { leMessage = "executing 1 tools in 1 batch(es)",
+          { leMessage = Just "executing 1 tools in 1 batch(es)",
             leLevel = Nothing,
             leToolName = Nothing,
             leBatches = Just [["grep"]],
             leMethod = Nothing,
-            lePath = Nothing,
-            leTimestamp = Nothing
+            lePath = Nothing
           }
   parseLine json @?= Just expected
 
@@ -41,84 +37,38 @@ testFormat :: IO ()
 testFormat = do
   let entry =
         LogEntry
-          { leMessage = "executing 1 tools in 1 batch(es)",
+          { leMessage = Just "executing 1 tools in 1 batch(es)",
             leLevel = Nothing,
             leToolName = Nothing,
             leBatches = Just [["grep"]],
             leMethod = Nothing,
-            lePath = Nothing,
-            leTimestamp = Nothing
+            lePath = Nothing
           }
-  format entry @?= Just "🤖  THOUGHT: Planning tool execution (grep)"
+  -- Expect NO emoji
+  formatLogEntry entry @?= Just "THOUGHT: Planning tool execution (grep)"
 
   let entry2 =
         LogEntry
-          { leMessage = "some random log",
+          { leMessage = Just "some random log",
             leLevel = Nothing,
             leToolName = Nothing,
             leBatches = Nothing,
             leMethod = Nothing,
-            lePath = Nothing,
-            leTimestamp = Nothing
+            lePath = Nothing
           }
-  format entry2 @?= Nothing
+  formatLogEntry entry2 @?= Nothing
 
   let entry3 =
         LogEntry
-          { leMessage = "some error",
+          { leMessage = Just "some error",
             leLevel = Just "error",
             leToolName = Nothing,
             leBatches = Nothing,
             leMethod = Nothing,
-            lePath = Nothing,
-            leTimestamp = Nothing
+            lePath = Nothing
           }
-  format entry3 @?= Just "❌  ERROR: some error"
-
-testUpdateStatus :: IO ()
-testUpdateStatus = do
-  let s0 = initialStatus "worker-1"
-  let e1 =
-        LogEntry
-          { leMessage = "executing 1 tools in 1 batch(es)",
-            leLevel = Nothing,
-            leToolName = Nothing,
-            leBatches = Just [["grep"]],
-            leMethod = Nothing,
-            lePath = Nothing,
-            leTimestamp = Just "12:00:00"
-          }
-  let s1 = updateStatus e1 s0
-  sLastActivity s1 @?= "🤖  THOUGHT: Planning tool execution (grep)"
-  sStartTime s1 @?= Just "12:00:00"
-
-  let e2 =
-        LogEntry
-          { leMessage = "ide-fs",
-            leLevel = Nothing,
-            leToolName = Nothing,
-            leBatches = Nothing,
-            leMethod = Just "readFile",
-            lePath = Just "/path/to/file",
-            leTimestamp = Just "12:00:01"
-          }
-  let s2 = updateStatus e2 s1
-  sLastActivity s2 @?= "📂  READ: /path/to/file"
-  Set.member "/path/to/file" (sFiles s2) @?= True
-  sStartTime s2 @?= Just "12:00:00" -- Should preserve start time
-
-testRenderStatus :: IO ()
-testRenderStatus = do
-  let s =
-        Status
-          { sWorkerName = "worker-1",
-            sTaskId = Just "t-123",
-            sFiles = Set.fromList ["file1", "file2"],
-            sStartTime = Just "12:00",
-            sLastActivity = "Running..."
-          }
-  let output = renderStatus s
-  output @?= "[Worker: worker-1] Task: t-123 | Files: 2\nRunning..."
+  -- Expect NO emoji
+  formatLogEntry entry3 @?= Just "ERROR: some error"
 
 (@?=) :: (Eq a, Show a) => a -> a -> IO ()
 (@?=) = (Test.@?=)