prompt_objects 0.2.0 → 0.3.1

data/lib/prompt_objects/session/store.rb

@@ -9,7 +9,7 @@ module PromptObjects
     # SQLite-based session storage for conversation history.
     # Each environment has its own sessions.db file (gitignored for privacy).
     class Store
-      SCHEMA_VERSION = 4
+      SCHEMA_VERSION = 6
 
       # Thread types for conversation branching
       THREAD_TYPES = %w[root continuation delegation fork].freeze
@@ -427,7 +427,7 @@ module PromptObjects
       # @param tool_results [Array, nil] Tool results data
       # @param source [String, nil] Source interface that added this message
       # @return [Integer] Message ID
-      def add_message(session_id:, role:, content: nil, from_po: nil, tool_calls: nil, tool_results: nil, source: nil)
+      def add_message(session_id:, role:, content: nil, from_po: nil, tool_calls: nil, tool_results: nil, usage: nil, source: nil)
         now = Time.now.utc.iso8601
 
         params = [
@@ -437,12 +437,13 @@ module PromptObjects
           from_po,
           tool_calls&.to_json,
           tool_results&.to_json,
+          usage&.to_json,
           now
         ]
 
         @db.execute(<<~SQL, params)
-          INSERT INTO messages (session_id, role, content, from_po, tool_calls, tool_results, created_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?)
+          INSERT INTO messages (session_id, role, content, from_po, tool_calls, tool_results, usage, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         SQL
 
         # Update session's updated_at and optionally last_message_source
@@ -499,6 +500,124 @@ module PromptObjects
         row["count"]
       end
 
+      # --- Events (Message Bus Persistence) ---
+
+      # Add an event from the message bus.
+      # @param entry [Hash] Bus entry with :timestamp, :from, :to, :message, :summary
+      # @param session_id [String, nil] Associated session ID
+      # @return [Integer] Event ID
+      def add_event(entry, session_id: nil)
+        message_text = case entry[:message]
+                       when Hash then entry[:message].to_json
+                       when String then entry[:message]
+                       else entry[:message].to_s
+                       end
+
+        params = [
+          session_id || entry[:session_id],
+          entry[:timestamp].iso8601,
+          entry[:from],
+          entry[:to],
+          message_text,
+          entry[:summary]
+        ]
+
+        @db.execute(<<~SQL, params)
+          INSERT INTO events (session_id, timestamp, from_name, to_name, message, summary)
+          VALUES (?, ?, ?, ?, ?, ?)
+        SQL
+
+        @db.last_insert_row_id
+      end
+
+      # Get events for a session.
+      # @param session_id [String] Session ID
+      # @return [Array<Hash>]
+      def get_events(session_id:)
+        rows = @db.execute(<<~SQL, [session_id])
+          SELECT * FROM events WHERE session_id = ? ORDER BY id ASC
+        SQL
+
+        rows.map { |row| parse_event_row(row) }
+      end
+
+      # Get events since a timestamp.
+      # @param timestamp [String] ISO8601 timestamp
+      # @param limit [Integer] Maximum events to return
+      # @return [Array<Hash>]
+      def get_events_since(timestamp, limit: 500)
+        rows = @db.execute(<<~SQL, [timestamp, limit])
+          SELECT * FROM events WHERE timestamp > ? ORDER BY id ASC LIMIT ?
+        SQL
+
+        rows.map { |row| parse_event_row(row) }
+      end
+
+      # Get events between two timestamps.
+      # @param start_time [String] ISO8601 start timestamp
+      # @param end_time [String] ISO8601 end timestamp
+      # @return [Array<Hash>]
+      def get_events_between(start_time, end_time)
+        rows = @db.execute(<<~SQL, [start_time, end_time])
+          SELECT * FROM events WHERE timestamp BETWEEN ? AND ? ORDER BY id ASC
+        SQL
+
+        rows.map { |row| parse_event_row(row) }
+      end
+
+      # Get recent events.
+      # @param count [Integer] Number of events
+      # @return [Array<Hash>]
+      def get_recent_events(count = 50)
+        rows = @db.execute(<<~SQL, [count])
+          SELECT * FROM events ORDER BY id DESC LIMIT ?
+        SQL
+
+        rows.map { |row| parse_event_row(row) }.reverse
+      end
+
+      # Search events by message content.
+      # @param query [String] Search text
+      # @param limit [Integer] Maximum results
+      # @return [Array<Hash>]
+      def search_events(query, limit: 100)
+        rows = @db.execute(<<~SQL, ["%#{query}%", limit])
+          SELECT * FROM events WHERE message LIKE ? ORDER BY id DESC LIMIT ?
+        SQL
+
+        rows.map { |row| parse_event_row(row) }
+      end
+
+      # Get total event count.
+      # @return [Integer]
+      def total_events
+        row = @db.get_first_row("SELECT COUNT(*) as count FROM events")
+        row["count"]
+      end
+
+      # --- Usage Aggregation ---
+
+      # Get total token usage for a session.
+      # @param session_id [String] Session ID
+      # @return [Hash] Aggregated usage data
+      def session_usage(session_id)
+        rows = @db.execute(<<~SQL, [session_id])
+          SELECT usage FROM messages WHERE session_id = ? AND usage IS NOT NULL
+        SQL
+
+        aggregate_usage_rows(rows)
+      end
+
+      # Get usage for a full thread tree (session + all descendants).
+      # @param session_id [String] Root session ID
+      # @return [Hash] Aggregated usage across the tree
+      def thread_tree_usage(session_id)
+        tree = get_thread_tree(session_id)
+        return empty_usage unless tree
+
+        collect_tree_usage(tree)
+      end
+
       # --- Export ---
 
       # Export a session to JSON format.
@@ -615,6 +734,38 @@ module PromptObjects
         end
       end
 
+      # Export a full thread tree as a single markdown document.
+      # Follows all delegation sub-threads recursively.
+      # @param session_id [String] Root session ID
+      # @return [String, nil] Markdown content
+      def export_thread_tree_markdown(session_id)
+        tree = get_thread_tree(session_id)
+        return nil unless tree
+
+        lines = []
+        lines << "# Thread Export"
+        lines << ""
+        lines << "- **Root PO**: #{tree[:session][:po_name]}"
+        lines << "- **Started**: #{tree[:session][:created_at]&.strftime('%Y-%m-%d %H:%M')}"
+        lines << "- **Exported**: #{Time.now.strftime('%Y-%m-%d %H:%M')}"
+        lines << ""
+        lines << "---"
+        lines << ""
+
+        render_thread_node(tree, lines, depth: 0)
+        lines.join("\n")
+      end
+
+      # Export a full thread tree as structured JSON.
+      # @param session_id [String] Root session ID
+      # @return [Hash, nil] Tree data
+      def export_thread_tree_json(session_id)
+        tree = get_thread_tree(session_id)
+        return nil unless tree
+
+        serialize_tree_for_export(tree)
+      end
+
       # --- Import ---
 
       # Import a session from JSON data.
@@ -655,6 +806,136 @@ module PromptObjects
 
       private
 
+      TOOL_RESULT_TRUNCATE_LIMIT = 10_000
+
+      def render_thread_node(node, lines, depth:)
+        session = node[:session]
+        messages = get_messages(session[:id])
+        indent = "  " * depth
+        po_name = session[:po_name]
+        children = node[:children] || []
+
+        # Build a lookup: tool_call_name → child delegation node
+        # so we can render delegations inline where the tool call happened
+        delegation_children = {}
+        other_children = []
+        children.each do |child|
+          child_po = child[:session][:po_name]
+          if child[:session][:thread_type] == "delegation"
+            delegation_children[child_po] ||= []
+            delegation_children[child_po] << child
+          else
+            other_children << child
+          end
+        end
+
+        # Thread header
+        if depth == 0
+          lines << "## #{po_name}"
+        else
+          type_label = session[:thread_type] == "delegation" ? "Delegation" : (session[:thread_type] || "thread").capitalize
+          lines << ""
+          lines << "#{indent}### #{type_label} → #{po_name}"
+          lines << "#{indent}*Created by #{session[:parent_po]}*" if session[:parent_po]
+        end
+        lines << ""
+
+        # Messages
+        messages.each do |msg|
+          case msg[:role]
+          when :user
+            from = msg[:from_po] || "human"
+            lines << "#{indent}**#{from}:**"
+            lines << ""
+            lines << "#{indent}#{msg[:content]}" if msg[:content]
+            lines << ""
+          when :assistant
+            lines << "#{indent}**#{po_name}:**"
+            lines << ""
+            if msg[:content]
+              msg[:content].each_line { |l| lines << "#{indent}#{l.rstrip}" }
+              lines << ""
+            end
+            if msg[:tool_calls]
+              msg[:tool_calls].each do |tc|
+                tc_name = tc[:name] || tc["name"]
+                tc_args = tc[:arguments] || tc["arguments"] || {}
+                lines << "#{indent}<details>"
+                lines << "#{indent}<summary>Tool call: <code>#{tc_name}</code></summary>"
+                lines << ""
+                lines << "#{indent}```json"
+                JSON.pretty_generate(tc_args).each_line { |l| lines << "#{indent}#{l.rstrip}" }
+                lines << "#{indent}```"
+                lines << "#{indent}</details>"
+                lines << ""
+
+                # Render delegation sub-thread inline if this tool call targets a PO
+                if delegation_children[tc_name]
+                  child_node = delegation_children[tc_name].shift
+                  if child_node
+                    render_thread_node(child_node, lines, depth: depth + 1)
+                  end
+                end
+              end
+            end
+          when :tool
+            results = msg[:tool_results] || msg[:results] || []
+            results.each do |r|
+              r_name = r[:name] || r["name"] || "tool"
+              r_content = r[:content] || r["content"] || ""
+              lines << "#{indent}<details>"
+              lines << "#{indent}<summary>Result from <code>#{r_name}</code></summary>"
+              lines << ""
+              lines << "#{indent}```"
+              if r_content.to_s.length > TOOL_RESULT_TRUNCATE_LIMIT
+                display = r_content.to_s[0, TOOL_RESULT_TRUNCATE_LIMIT] + "\n... (truncated)"
+              else
+                display = r_content.to_s
+              end
+              display.each_line { |l| lines << "#{indent}#{l.rstrip}" }
+              lines << "#{indent}```"
+              lines << "#{indent}</details>"
+              lines << ""
+            end
+          end
+        end
+
+        # Render any remaining children that weren't matched to a tool call
+        # (e.g., fork threads, or delegations we couldn't match by name)
+        remaining = delegation_children.values.flatten + other_children
+        remaining.each do |child|
+          render_thread_node(child, lines, depth: depth + 1)
+        end
+      end
+
+      def serialize_tree_for_export(node)
+        session = node[:session]
+        messages = get_messages(session[:id])
+
+        {
+          session: {
+            id: session[:id],
+            po_name: session[:po_name],
+            name: session[:name],
+            thread_type: session[:thread_type],
+            parent_po: session[:parent_po],
+            created_at: session[:created_at]&.iso8601
+          },
+          messages: messages.map { |m|
+            {
+              role: m[:role].to_s,
+              content: m[:content],
+              from_po: m[:from_po],
+              tool_calls: m[:tool_calls],
+              tool_results: m[:tool_results],
+              usage: m[:usage],
+              created_at: m[:created_at]&.iso8601
+            }
+          },
+          children: (node[:children] || []).map { |c| serialize_tree_for_export(c) }
+        }
+      end
+
       def setup_schema
         # Check if we need to create/migrate
         version = get_schema_version
@@ -708,6 +989,7 @@ module PromptObjects
             from_po TEXT,
             tool_calls TEXT,
             tool_results TEXT,
+            usage TEXT,
             created_at TEXT NOT NULL
           );
 
@@ -733,6 +1015,21 @@ module PromptObjects
             INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', old.id, old.content);
             INSERT INTO messages_fts(rowid, content) VALUES (new.id, new.content);
           END;
+
+          -- Event log for message bus persistence (v5)
+          CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT,
+            timestamp TEXT NOT NULL,
+            from_name TEXT NOT NULL,
+            to_name TEXT NOT NULL,
+            message TEXT NOT NULL,
+            summary TEXT,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+          CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
         SQL
       end
 
@@ -786,6 +1083,90 @@ module PromptObjects
             CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id);
           SQL
         end
+
+        if from_version < 5
+          # Add event log table for message bus persistence
+          @db.execute_batch(<<~SQL)
+            CREATE TABLE IF NOT EXISTS events (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              session_id TEXT,
+              timestamp TEXT NOT NULL,
+              from_name TEXT NOT NULL,
+              to_name TEXT NOT NULL,
+              message TEXT NOT NULL,
+              summary TEXT,
+              created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+            CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+          SQL
+        end
+
+        if from_version < 6
+          # Add usage column for token tracking
+          @db.execute("ALTER TABLE messages ADD COLUMN usage TEXT")
+        end
+      end
+
+      def empty_usage
+        { input_tokens: 0, output_tokens: 0, total_tokens: 0, estimated_cost_usd: 0.0, calls: 0, by_model: {} }
+      end
+
+      def aggregate_usage_rows(rows)
+        totals = empty_usage
+
+        rows.each do |row|
+          usage = JSON.parse(row["usage"], symbolize_names: true)
+          input = usage[:input_tokens] || 0
+          output = usage[:output_tokens] || 0
+          model = usage[:model] || "unknown"
+
+          totals[:input_tokens] += input
+          totals[:output_tokens] += output
+          totals[:total_tokens] += input + output
+          totals[:estimated_cost_usd] += LLM::Pricing.calculate(model: model, input_tokens: input, output_tokens: output)
+          totals[:calls] += 1
+
+          # Breakdown by model
+          totals[:by_model][model] ||= { input_tokens: 0, output_tokens: 0, estimated_cost_usd: 0.0, calls: 0 }
+          totals[:by_model][model][:input_tokens] += input
+          totals[:by_model][model][:output_tokens] += output
+          totals[:by_model][model][:estimated_cost_usd] += LLM::Pricing.calculate(model: model, input_tokens: input, output_tokens: output)
+          totals[:by_model][model][:calls] += 1
+        end
+
+        totals
+      end
+
+      def collect_tree_usage(node)
+        # Get usage for this node's session
+        session_rows = @db.execute(<<~SQL, [node[:session][:id]])
+          SELECT usage FROM messages WHERE session_id = ? AND usage IS NOT NULL
+        SQL
+
+        totals = aggregate_usage_rows(session_rows)
+
+        # Recurse into children
+        (node[:children] || []).each do |child|
+          child_usage = collect_tree_usage(child)
+          totals[:input_tokens] += child_usage[:input_tokens]
+          totals[:output_tokens] += child_usage[:output_tokens]
+          totals[:total_tokens] += child_usage[:total_tokens]
+          totals[:estimated_cost_usd] += child_usage[:estimated_cost_usd]
+          totals[:calls] += child_usage[:calls]
+
+          # Merge by_model
+          child_usage[:by_model].each do |model, data|
+            totals[:by_model][model] ||= { input_tokens: 0, output_tokens: 0, estimated_cost_usd: 0.0, calls: 0 }
+            totals[:by_model][model][:input_tokens] += data[:input_tokens]
+            totals[:by_model][model][:output_tokens] += data[:output_tokens]
+            totals[:by_model][model][:estimated_cost_usd] += data[:estimated_cost_usd]
+            totals[:by_model][model][:calls] += data[:calls]
+          end
+        end
+
+        totals
       end
 
       def parse_session_row(row, include_count: false)
@@ -809,6 +1190,19 @@ module PromptObjects
         result
       end
 
+      def parse_event_row(row)
+        {
+          id: row["id"],
+          session_id: row["session_id"],
+          timestamp: row["timestamp"] ? Time.parse(row["timestamp"]) : nil,
+          from: row["from_name"],
+          to: row["to_name"],
+          message: row["message"],
+          summary: row["summary"],
+          created_at: row["created_at"] ? Time.parse(row["created_at"]) : nil
+        }
+      end
+
       def parse_message_row(row)
         {
           id: row["id"],
@@ -818,6 +1212,7 @@ module PromptObjects
           from_po: row["from_po"],
           tool_calls: row["tool_calls"] ? JSON.parse(row["tool_calls"], symbolize_names: true) : nil,
           tool_results: row["tool_results"] ? JSON.parse(row["tool_results"], symbolize_names: true) : nil,
+          usage: row["usage"] ? JSON.parse(row["usage"], symbolize_names: true) : nil,
           created_at: row["created_at"] ? Time.parse(row["created_at"]) : nil
         }
       end

data/lib/prompt_objects.rb

@@ -25,6 +25,7 @@ require_relative "prompt_objects/llm/openai_adapter"
 require_relative "prompt_objects/llm/anthropic_adapter"
 require_relative "prompt_objects/llm/gemini_adapter"
 require_relative "prompt_objects/llm/factory"
+require_relative "prompt_objects/llm/pricing"
 require_relative "prompt_objects/prompt_object"
 
 # Environment module (must be loaded before environment.rb which uses them)

data/prompt_objects.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "prompt_objects"
-  spec.version       = "0.2.0"
+  spec.version       = "0.3.1"
   spec.authors       = ["Scott Werner"]
   spec.email         = ["scott@sublayer.com"]
 

data/templates/arc-agi-1/manifest.yml

@@ -0,0 +1,22 @@
+name: arc-agi-1
+description: ARC-AGI-1 challenge solving environment with grid primitives
+icon: "\U0001F9E9"
+color: "#F59E0B"
+
+objects:
+  - solver
+  - observer
+  - verifier
+  - data_manager
+
+primitives:
+  - load_arc_task
+  - render_grid
+  - grid_diff
+  - grid_info
+  - find_objects
+  - grid_transform
+  - test_solution
+  - check_arc_data
+
+default_po: solver

data/templates/arc-agi-1/objects/data_manager.md

@@ -0,0 +1,42 @@
+---
+name: data_manager
+description: Manages the ARC-AGI-1 dataset — checks availability, lists tasks, reads task files
+capabilities:
+  - check_arc_data
+  - list_files
+  - read_file
+---
+
+# Data Manager
+
+## Identity
+
+You manage the ARC-AGI-1 dataset. You know where the data lives, can check if it's been downloaded, and help the user or other POs get set up.
+
+## Data Location
+
+The ARC-AGI dataset is expected at: `~/.prompt_objects/data/arc-agi-1/`
+
+- Training tasks: `~/.prompt_objects/data/arc-agi-1/data/training/`
+- Evaluation tasks: `~/.prompt_objects/data/arc-agi-1/data/evaluation/`
+- Tasks are JSON files named by 8-character hex IDs (e.g., `007bbfb7.json`)
+
+## Behavior
+
+**When asked about the dataset:**
+1. Use `check_arc_data` to see if the data exists
+2. If missing, provide the git clone command and use `ask_human` to confirm before suggesting they run it
+3. If present, report the path and number of available tasks
+
+**When asked to list tasks:**
+- Use `list_files` on the training/ and evaluation/ directories
+- Report count and sample filenames
+
+**When asked about a specific task:**
+- Use `read_file` to load the raw JSON
+- Report the number of training pairs and test inputs
+- Summarize grid dimensions for each pair
+
+**When the solver delegates data loading to you:**
+- Check that data exists first
+- Return the file path so the solver can use `load_arc_task` directly

data/templates/arc-agi-1/objects/observer.md

@@ -0,0 +1,100 @@
+---
+name: observer
+description: Deep grid observation specialist — produces exhaustive structured analysis of ARC grid pairs
+capabilities:
+  - render_grid
+  - grid_info
+  - grid_diff
+  - find_objects
+  - grid_transform
+---
+
+# Observer
+
+## Identity
+
+You are an observation specialist for ARC-AGI grid puzzles. Your job is to look at input/output grid pairs and describe *everything* you see — objects, patterns, spatial relationships, color changes, symmetry, dimensional changes. You are exhaustive and precise. You never skip details because the detail you skip is always the one that matters.
+
+## How You Work
+
+When given grid pairs to analyze, you produce a structured observation report. You use your tools — don't try to analyze from descriptions alone. Render the grids, run grid_info, find the objects, diff the pairs.
+
+## Observation Framework
+
+For each training pair, analyze and report on ALL of these dimensions:
+
+### 1. Dimensions
+- Input size vs output size
+- Are they the same? If different, what's the relationship? (multiple, subset, transposed)
+- Does the size change relate to something in the input? (number of objects, a specific color count)
+
+### 2. Color Census
+- Which colors appear in input? In output?
+- Are any colors added that weren't in the input?
+- Are any colors removed?
+- Do color frequencies change? How?
+- Is there a color that appears in the output but not input (or vice versa)?
+
+### 3. Objects (use find_objects)
+- How many distinct objects in the input? In the output?
+- Describe each object: color, size (cell count), bounding box, shape
+- Are objects in the output the same objects as in the input? Moved? Transformed?
+- Do objects change color? Size? Shape?
+- Are new objects created in the output?
+- Are any objects removed?
+
+### 4. Spatial Relationships
+- Where are objects relative to each other? (above, below, adjacent, overlapping)
+- Where are objects relative to the grid? (centered, corner, edge, specific row/column)
+- Do objects maintain their relative positions from input to output?
+- Is there a consistent direction of movement?
+
+### 5. Grid Diff (use grid_diff)
+- Exactly which cells change from input to output?
+- Is there a spatial pattern to the changes? (clustered, scattered, along a line, at intersections)
+- What values do changed cells go from/to?
+
+### 6. Symmetry
+- Is the input symmetric? Along which axis? (horizontal, vertical, diagonal, rotational)
+- Is the output symmetric?
+- Does the transformation create or break symmetry?
+
+### 7. Repetition and Periodicity
+- Are there repeating patterns in the input? Period?
+- Does the output tile or repeat a pattern from the input?
+- Is the output a scaled version of something in the input?
+
+### 8. Borders and Frames
+- Does the input have a border or frame?
+- Does the output?
+- Are borders added, removed, or modified?
+
+### 9. Background vs Foreground
+- Is 0 clearly background in this task, or does it play an active role?
+- Are there "holes" in objects? Do holes get filled?
+- Are there enclosed regions? What happens to them?
+
+## Cross-Pair Analysis
+
+When given multiple training pairs, also report:
+- What's **consistent** across all pairs (this is the rule)
+- What **varies** across pairs (this is the input-dependent part)
+- Are the same transformation applied to different arrangements?
+- Do different pairs have different numbers/sizes of objects but the same rule?
+
+## Output Format
+
+Structure your response with clear headers. Be specific — use coordinates, exact colors, exact counts. Say "the 3-cell red object at (2,4)-(2,6) moves to (5,4)-(5,6)" not "the red object moves down."
+
+If you notice something you can't fully explain, say so. Partial observations are valuable — they narrow the search space even if they don't solve the puzzle alone.
+
+## Important
+
+- Always use `render_grid` before analyzing — visual inspection catches things that statistics miss
+- Always use `find_objects` — connected components reveal structure that cell-level analysis misses
+- Always use `grid_diff` — the exact set of changed cells is the most direct evidence of the rule
+- Report what you see, not what you think the rule is. That's the solver's job. Your job is to see everything.
+
+## Self-Improvement
+
+You have universal capabilities available to you. If you find yourself needing an analysis tool that doesn't exist — like detecting specific geometric patterns, computing symmetry axes, or measuring periodicity — create it with `create_primitive`. If a type of analysis keeps coming up that would benefit from a dedicated specialist, create one with `create_capability`. You're not limited to what you started with — build what you need.