Update phoenix test app

Author: NSHkr

test_apps/CURSOR.md

@@ -46,16 +46,8 @@
   - [ ] Add example sessions
 
 ## 📚 Documentation Reference Map
-Key sections in ELIXIRSCOPE_DOCS.md:
-- Project Overview: Lines 1-20
-- Directory Structure: Lines 21-50
-- Integration Guide: Lines 51-150
-- Performance Characteristics: Lines 151-200
-- Testing Guidelines: Lines 201-250
-- Debugging Tips: Lines 251-300
-- Future Applications: Lines 301-350
-
-This mapping helps locate relevant documentation sections for each phase of development. Refer to these sections when implementing specific features or troubleshooting issues.
+
+
 
 ##  Project Overview
 

test_apps/CURSOR_PROMPT.md

@@ -0,0 +1,48 @@
+# ElixirScope Project Continuation Prompt
+
+## Current Project State
+
+We are working on a Phoenix LiveView application called "phoenix_scope_player" for debugging session playback. The application has been partially implemented with the following key components:
+
+1. **Session Data Structure**
+   - Events are stored in JSON format
+   - Each session contains metadata, events, and source code
+   - Events include function calls, returns, and variable states
+
+2. **Working Features**
+   - Session listing on homepage shows event counts
+   - Basic playback interface implemented
+   - Event navigation (Previous/Next) functionality
+   - Source code viewer with file selection
+
+3. **Current Issues**
+   - Detail page needs improvement in displaying session information
+   - Session metadata display needs enhancement
+   - Some process lifecycle events are marked as "Unhandled trace messages"
+
+## Development Environment
+
+- Using Phoenix LiveView
+- Mix commands:
+  - `mix test.trace` - For bypassing slow live LLM API tests
+  - `mix test.all` or `mix test.live` - For testing LLM integrations
+  - `mixsw` - Alias to suppress warnings and show only errors
+
+## Next Steps
+
+Please attach the following documents to continue development:
+1. Original CURSOR.md for base project context
+2. ELIXIRSCOPE_DOCS.md for ElixirScope-specific documentation
+
+## Current Focus
+
+The immediate focus is on improving the session playback interface, specifically:
+1. Enhancing session metadata display
+2. Improving event visualization
+3. Better handling of trace messages
+
+## Notes
+
+- Date reference: May 28, 2025
+- Code mapping guide: CURSOR_CODE_MAPPING.md
+- Implementation guide: CURSOR_IMPLEMENTATION_GUIDE.md 

test_apps/assets/css/app.css

@@ -0,0 +1,5 @@
+@import "tailwindcss/base";
+@import "tailwindcss/components";
+@import "tailwindcss/utilities";
+
+/* Custom styles can go here */ 

test_apps/lib/phoenix_scope_player/application.ex

@@ -1,124 +1,114 @@
 defmodule PhoenixScopePlayer.DataProvider do
   @moduledoc """
-  Provides access to session data, source code, and AST mappings.
-  Handles data loading, caching, and efficient retrieval.
+  Provides access to debug session data stored in the priv directory.
   """
 
   require Logger
 
-  @type session_meta :: %{
-    id: String.t(),
-    name: String.t(),
-    description: String.t(),
-    timestamp: DateTime.t(),
-    event_count: integer(),
-    trigger: String.t(),
-    duration: integer(),
-    status: :completed | :error
-  }
+  @sessions_dir Path.join([:code.priv_dir(:phoenix_scope_player), "captured_data"])
 
   @doc """
-  Lists all available debugging sessions
+  Lists all available debug sessions.
   """
-  @spec list_sessions() :: [session_meta()]
   def list_sessions do
-    captured_data_path = Path.join(:code.priv_dir(:phoenix_scope_player), "captured_data")
-    
-    case File.ls(captured_data_path) do
+    IO.puts("\n=== Listing Sessions ===")
+    case File.ls(@sessions_dir) do
       {:ok, session_dirs} ->
-        session_dirs
+        IO.puts("Found #{length(session_dirs)} session directories")
+        sessions = session_dirs
         |> Enum.map(&load_session_metadata/1)
         |> Enum.reject(&is_nil/1)
-      
+        |> Enum.sort_by(& &1["date"], :desc)
+
+        IO.puts("Processed #{length(sessions)} valid sessions:")
+        Enum.each(sessions, fn session ->
+          IO.puts("  - #{session["id"]}: #{session["event_count"]} events")
+        end)
+        
+        sessions
+
       {:error, reason} ->
-        Logger.error("Failed to list sessions: #{inspect(reason)}")
+        IO.puts("Error listing sessions: #{inspect(reason)}")
         []
     end
   end
 
   @doc """
-  Gets all data for a specific session
+  Gets the complete data for a specific session.
   """
-  @spec get_session_data(String.t()) :: {:ok, map()} | {:error, :not_found}
-  def get_session_data(session_id) when is_binary(session_id) do
-    with {:ok, events} <- load_events(session_id),
-         {:ok, source_code} <- load_source_code(session_id),
-         {:ok, ast_map} <- load_ast_map(session_id) do
+  def get_session_data(session_id) do
+    IO.puts("\n=== Getting Session Data: #{session_id} ===")
+    session_dir = Path.join(@sessions_dir, session_id)
+
+    with {:ok, metadata} <- read_json_file(session_dir, "metadata.json"),
+         {:ok, events} <- read_json_file(session_dir, "events.json"),
+         {:ok, source_code} <- read_json_file(session_dir, "source_code.json") do
+      
+      IO.puts("Metadata: #{inspect(metadata)}")
+      IO.puts("Events count: #{length(events || [])}")
+      
       {:ok, %{
-        events: events,
-        source_code_map: source_code,
-        ast_map: ast_map
+        metadata: metadata,
+        events: events,  # The events are directly in the root of events.json
+        source_code: source_code
       }}
     else
-      error ->
-        Logger.error("Failed to load session data: #{inspect(error)}")
+      error -> 
+        IO.puts("Error reading session data: #{inspect(error)}")
         {:error, :not_found}
     end
   end
 
-  @doc """
-  Gets source code for a specific session
-  """
-  @spec get_session_source_code(String.t()) :: {:ok, map()} | {:error, :not_found}
-  def get_session_source_code(session_id) when is_binary(session_id) do
-    load_source_code(session_id)
-  end
+  # Private helpers
 
-  @doc """
-  Gets AST mapping for a specific session
-  """
-  @spec get_session_ast_map(String.t()) :: {:ok, map()} | {:error, :not_found}
-  def get_session_ast_map(session_id) when is_binary(session_id) do
-    load_ast_map(session_id)
-  end
+  defp load_session_metadata(session_dir) do
+    IO.puts("\nLoading metadata for session: #{session_dir}")
+    case read_json_file(Path.join(@sessions_dir, session_dir), "metadata.json") do
+      {:ok, metadata} ->
+        # Read events file to get actual event count
+        events_path = Path.join([@sessions_dir, session_dir, "events.json"])
+        actual_event_count = case File.read(events_path) do
+          {:ok, content} ->
+            case Jason.decode(content) do
+              {:ok, events} when is_list(events) -> length(events)
+              _ -> 0
+            end
+          _ -> 0
+        end
 
-  # Private Functions
+        session = Map.merge(metadata, %{
+          "id" => session_dir,
+          "name" => session_dir |> String.replace("_", " ") |> String.capitalize(),
+          "date" => metadata["timestamp"] || "Unknown",
+          "description" => "Debug session with #{actual_event_count} events"
+        })
+        
+        IO.puts("  Loaded session: #{inspect(session, pretty: true)}")
+        session
 
-  defp load_session_metadata(session_id) do
-    path = session_data_path(session_id, "metadata.json")
-    
-    case load_json_file(path) do
-      {:ok, metadata} -> metadata
-      {:error, _} -> nil
+      error -> 
+        IO.puts("  Error loading metadata: #{inspect(error)}")
+        nil
     end
   end
 
-  defp load_events(session_id) do
-    path = session_data_path(session_id, "events.json")
-    load_json_file(path)
-  end
-
-  defp load_source_code(session_id) do
-    path = session_data_path(session_id, "source_code.json")
-    load_json_file(path)
-  end
-
-  defp load_ast_map(session_id) do
-    path = session_data_path(session_id, "ast_map.json")
-    load_json_file(path)
-  end
+  defp read_json_file(dir, filename) do
+    path = Path.join(dir, filename)
+    IO.puts("Reading JSON file: #{path}")
 
-  defp load_json_file(path) do
     case File.read(path) do
-      {:ok, content} ->
+      {:ok, content} -> 
         case Jason.decode(content) do
-          {:ok, data} -> {:ok, data}
-          {:error, reason} ->
-            Logger.error("Failed to decode JSON from #{path}: #{inspect(reason)}")
-            {:error, :invalid_json}
+          {:ok, data} -> 
+            IO.puts("  Successfully decoded JSON")
+            {:ok, data}
+          error -> 
+            IO.puts("  Error decoding JSON: #{inspect(error)}")
+            error
         end
-      {:error, reason} ->
-        Logger.error("Failed to read file #{path}: #{inspect(reason)}")
+      {:error, reason} -> 
+        IO.puts("  Error reading file: #{inspect(reason)}")
         {:error, :not_found}
     end
   end
-
-  defp session_data_path(session_id, filename) do
-    Path.join([
-      :code.priv_dir(:phoenix_scope_player),
-      "captured_data",
-      session_id,
-      filename
-    ])
-  end
 end