anima-core 1.1.3 → 1.3.0

data/app/models/event.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-# A persisted record of something that happened during a session.
-# Events are the single source of truth for conversation history —
-# there is no separate chat log, only events attached to a session.
-#
-# @!attribute event_type
-#   @return [String] one of {TYPES}: system_message, user_message,
-#     agent_message, tool_call, tool_response
-# @!attribute payload
-#   @return [Hash] event-specific data (content, tool_name, tool_input, etc.)
-# @!attribute timestamp
-#   @return [Integer] nanoseconds since epoch (Process::CLOCK_REALTIME)
-# @!attribute token_count
-#   @return [Integer] cached token count for this event's payload (0 until counted)
-# @!attribute tool_use_id
-#   @return [String] ID correlating tool_call and tool_response events
-#     (Anthropic-assigned, or a SecureRandom.uuid fallback when the API returns nil;
-#     required for tool_call and tool_response events)
-class Event < ApplicationRecord
-  include Event::Broadcasting
-
-  TYPES = %w[system_message user_message agent_message tool_call tool_response].freeze
-  LLM_TYPES = %w[user_message agent_message].freeze
-  CONTEXT_TYPES = %w[system_message user_message agent_message tool_call tool_response].freeze
-  CONVERSATION_TYPES = %w[user_message agent_message system_message].freeze
-  THINK_TOOL = "think"
-  SPAWN_TOOLS = %w[spawn_subagent spawn_specialist].freeze
-  PENDING_STATUS = "pending"
-
-  # Event types that require a tool_use_id to pair call with response.
-  TOOL_TYPES = %w[tool_call tool_response].freeze
-
-  ROLE_MAP = {"user_message" => "user", "agent_message" => "assistant"}.freeze
-
-  # Heuristic: average bytes per token for English prose.
-  BYTES_PER_TOKEN = 4
-
-  belongs_to :session
-  has_many :pinned_events, dependent: :destroy
-
-  validates :event_type, presence: true, inclusion: {in: TYPES}
-  validates :payload, presence: true
-  validates :timestamp, presence: true
-  # Anthropic requires every tool_use to have a matching tool_result with the same ID
-  validates :tool_use_id, presence: true, if: -> { event_type.in?(TOOL_TYPES) }
-
-  after_create :schedule_token_count, if: :llm_message?
-
-  # @!method self.llm_messages
-  #   Events that represent conversation turns sent to the LLM API.
-  #   @return [ActiveRecord::Relation]
-  scope :llm_messages, -> { where(event_type: LLM_TYPES) }
-
-  # @!method self.context_events
-  #   Events included in the LLM context window (messages + tool interactions).
-  #   @return [ActiveRecord::Relation]
-  scope :context_events, -> { where(event_type: CONTEXT_TYPES) }
-
-  # @!method self.pending
-  #   User messages queued during active agent processing, not yet sent to LLM.
-  #   @return [ActiveRecord::Relation]
-  scope :pending, -> { where(status: PENDING_STATUS) }
-
-  # @!method self.deliverable
-  #   Events eligible for LLM context (excludes pending messages).
-  #   NULL status means delivered/processed — the only excluded value is "pending".
-  #   @return [ActiveRecord::Relation]
-  scope :deliverable, -> { where(status: nil) }
-
-  # @!method self.excluding_spawn_events
-  #   Excludes spawn_subagent/spawn_specialist tool_call and tool_response events.
-  #   Used when building parent context for sub-agents — spawn events cause role
-  #   confusion because the sub-agent sees sibling spawn results and mistakes
-  #   itself for the parent.
-  #   @return [ActiveRecord::Relation]
-  scope :excluding_spawn_events, -> {
-    where.not("event_type IN (?) AND json_extract(payload, '$.tool_name') IN (?)",
-      TOOL_TYPES, SPAWN_TOOLS)
-  }
-
-  # Maps event_type to the Anthropic Messages API role.
-  # @return [String] "user" or "assistant"
-  def api_role
-    ROLE_MAP.fetch(event_type)
-  end
-
-  # @return [Boolean] true if this event represents an LLM conversation turn
-  def llm_message?
-    event_type.in?(LLM_TYPES)
-  end
-
-  # @return [Boolean] true if this event is part of the LLM context window
-  def context_event?
-    event_type.in?(CONTEXT_TYPES)
-  end
-
-  # @return [Boolean] true if this is a pending message not yet sent to the LLM
-  def pending?
-    status == PENDING_STATUS
-  end
-
-  # @return [Boolean] true if this is a conversation event (user/agent/system message)
-  #   or a think tool_call — the events Mneme treats as "conversation" for boundary tracking
-  def conversation_or_think?
-    event_type.in?(CONVERSATION_TYPES) ||
-      (event_type == "tool_call" && payload["tool_name"] == THINK_TOOL)
-  end
-
-  # Heuristic token estimate: ~4 bytes per token for English prose.
-  # Tool events are estimated from the full payload JSON since tool_input
-  # and tool metadata contribute to token count. Messages use content only.
-  #
-  # @return [Integer] estimated token count (at least 1)
-  def estimate_tokens
-    text = if event_type.in?(TOOL_TYPES)
-      payload.to_json
-    else
-      payload["content"].to_s
-    end
-    [(text.bytesize / BYTES_PER_TOKEN.to_f).ceil, 1].max
-  end
-
-  private
-
-  def schedule_token_count
-    CountEventTokensJob.perform_later(id)
-  end
-end

data/app/models/goal_pinned_event.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-# Join record linking a {Goal} to a {PinnedEvent}. Many-to-many: one event
-# can be pinned to multiple Goals, and one Goal can reference multiple pins.
-# When the last Goal referencing a pin completes, the pin is released.
-class GoalPinnedEvent < ApplicationRecord
-  belongs_to :goal
-  belongs_to :pinned_event
-
-  validates :pinned_event_id, uniqueness: {scope: :goal_id}
-end

data/app/models/pinned_event.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# A conversation event pinned to one or more Goals by Mneme to protect it
-# from viewport eviction. Pinned events appear in the Goals section of
-# the viewport, giving the main agent access to critical context that
-# would otherwise scroll out of the sliding window.
-#
-# Pinning is goal-scoped: when all Goals referencing a pin complete,
-# the pin is automatically released (reference-counted cleanup).
-#
-# @!attribute display_text
-#   @return [String] truncated event content (~200 chars) shown in the Goals section
-class PinnedEvent < ApplicationRecord
-  # Display text limit — enough to recognize content, cheap on tokens.
-  MAX_DISPLAY_TEXT_LENGTH = 200
-
-  belongs_to :event
-
-  has_many :goal_pinned_events, dependent: :destroy
-  has_many :goals, through: :goal_pinned_events
-
-  validates :display_text, presence: true, length: {maximum: MAX_DISPLAY_TEXT_LENGTH}
-  validates :event_id, uniqueness: true
-
-  # Pinned events with no remaining active goals — safe to release.
-  #
-  # @return [ActiveRecord::Relation]
-  scope :orphaned, -> {
-    where.not(
-      "EXISTS (SELECT 1 FROM goal_pinned_events gpe " \
-      "JOIN goals ON goals.id = gpe.goal_id " \
-      "WHERE gpe.pinned_event_id = pinned_events.id " \
-      "AND goals.status = 'active')"
-    )
-  }
-
-  # @return [Integer] token cost estimate for viewport budget accounting
-  def token_cost
-    [(display_text.bytesize / Event::BYTES_PER_TOKEN.to_f).ceil, 1].max
-  end
-end

data/lib/mneme/tools/attach_events_to_goals.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Mneme
-  module Tools
-    # Pins critical events to active Goals so they survive viewport eviction.
-    # Mneme calls this when it sees important events (user instructions, key
-    # decisions, critical corrections) approaching the eviction zone.
-    #
-    # Events are pinned via a many-to-many join: one event can be attached
-    # to multiple Goals. When all referencing Goals complete, the pin is
-    # automatically released (reference-counted cleanup in {Goal#release_orphaned_pins!}).
-    class AttachEventsToGoals < ::Tools::Base
-      def self.tool_name = "attach_events_to_goals"
-
-      def self.description = "Pin critical events to active goals so they survive " \
-        "viewport eviction. Use this for events that are too important to lose — " \
-        "exact user instructions, key decisions, critical corrections. " \
-        "Events stay pinned until all attached goals complete."
-
-      def self.input_schema
-        {
-          type: "object",
-          properties: {
-            event_ids: {
-              type: "array",
-              items: {type: "integer"},
-              description: "Database IDs of events to pin (from `event N` prefixes in the viewport)"
-            },
-            goal_ids: {
-              type: "array",
-              items: {type: "integer"},
-              description: "IDs of active goals to attach the events to"
-            }
-          },
-          required: %w[event_ids goal_ids]
-        }
-      end
-
-      # @param main_session [Session] the session being observed
-      def initialize(main_session:, **)
-        @session = main_session
-      end
-
-      # @param input [Hash<String, Object>] with "event_ids" and "goal_ids"
-      # @return [String] confirmation with link count, or error description
-      def execute(input)
-        event_ids = Array(input["event_ids"]).map(&:to_i).uniq
-        goal_ids = Array(input["goal_ids"]).map(&:to_i).uniq
-
-        return "Error: event_ids cannot be empty" if event_ids.empty?
-        return "Error: goal_ids cannot be empty" if goal_ids.empty?
-
-        events = @session.events.where(id: event_ids)
-        goals = @session.goals.active.where(id: goal_ids)
-
-        missing_events = event_ids - events.pluck(:id)
-        inactive_goal_ids = goal_ids - goals.pluck(:id)
-
-        errors = []
-        errors << "Events not found: #{missing_events.join(", ")}" if missing_events.any?
-
-        if inactive_goal_ids.any?
-          completed_ids = @session.goals.completed.where(id: inactive_goal_ids).pluck(:id)
-          not_found_ids = inactive_goal_ids - completed_ids
-          errors << "Goals already completed: #{completed_ids.join(", ")}" if completed_ids.any?
-          errors << "Goals not found: #{not_found_ids.join(", ")}" if not_found_ids.any?
-        end
-
-        return "Error: #{errors.join("; ")}" if errors.any?
-
-        attached = attach(events, goals)
-        "Pinned #{attached} event-goal links"
-      end
-
-      private
-
-      def attach(events, goals)
-        events.sum do |event|
-          pinned = find_or_create_pinned_event(event)
-          link_to_goals(pinned, goals)
-        end
-      end
-
-      def link_to_goals(pinned, goals)
-        goals.each { |goal| GoalPinnedEvent.find_or_create_by!(goal: goal, pinned_event: pinned) }
-        goals.size
-      end
-
-      def find_or_create_pinned_event(event)
-        PinnedEvent.find_or_create_by!(event: event) do |pe|
-          pe.display_text = truncate_event_content(event)
-        end
-      end
-
-      def truncate_event_content(event)
-        content = event.payload&.dig("content").to_s.strip
-        content = "event #{event.id}" if content.empty?
-
-        if content.length > PinnedEvent::MAX_DISPLAY_TEXT_LENGTH
-          content[0, PinnedEvent::MAX_DISPLAY_TEXT_LENGTH - 1] + "…"
-        else
-          content
-        end
-      end
-    end
-  end
-end