anima-core 0.0.1 → 0.1.0

data/db/migrate/20260308124203_create_events.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateEvents < ActiveRecord::Migration[8.1]
+  def change
+    create_table :events do |t|
+      t.references :session, null: false, foreign_key: true
+      t.string :event_type, null: false
+      t.json :payload, null: false, default: {}
+      t.integer :position, null: false
+      t.integer :timestamp, limit: 8, null: false
+
+      t.timestamps
+    end
+
+    add_index :events, [:session_id, :position]
+    add_index :events, :event_type
+  end
+end

data/db/migrate/20260308130000_add_event_indexes.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddEventIndexes < ActiveRecord::Migration[8.1]
+  def change
+    remove_index :events, [:session_id, :position]
+    add_index :events, [:session_id, :position], unique: true
+    add_index :events, [:session_id, :event_type]
+  end
+end

data/db/migrate/20260308140000_remove_position_from_events.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class RemovePositionFromEvents < ActiveRecord::Migration[8.1]
+  def change
+    remove_index :events, [:session_id, :position]
+    remove_column :events, :position, :integer, null: false
+  end
+end

data/db/migrate/20260308150000_add_token_count_to_events.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddTokenCountToEvents < ActiveRecord::Migration[8.1]
+  def change
+    add_column :events, :token_count, :integer, default: 0, null: false
+  end
+end

data/db/migrate/20260308160000_add_tool_use_id_to_events.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AddToolUseIdToEvents < ActiveRecord::Migration[8.1]
+  def change
+    add_column :events, :tool_use_id, :string
+    add_index :events, :tool_use_id
+  end
+end

data/db/queue_schema.rb

@@ -0,0 +1,141 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[8.1].define(version: 1) do
+  create_table "solid_queue_blocked_executions", force: :cascade do |t|
+    t.string "concurrency_key", null: false
+    t.datetime "created_at", null: false
+    t.datetime "expires_at", null: false
+    t.bigint "job_id", null: false
+    t.integer "priority", default: 0, null: false
+    t.string "queue_name", null: false
+    t.index ["concurrency_key", "priority", "job_id"], name: "index_solid_queue_blocked_executions_for_release"
+    t.index ["expires_at", "concurrency_key"], name: "index_solid_queue_blocked_executions_for_maintenance"
+    t.index ["job_id"], name: "index_solid_queue_blocked_executions_on_job_id", unique: true
+  end
+
+  create_table "solid_queue_claimed_executions", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.bigint "job_id", null: false
+    t.bigint "process_id"
+    t.index ["job_id"], name: "index_solid_queue_claimed_executions_on_job_id", unique: true
+    t.index ["process_id", "job_id"], name: "index_solid_queue_claimed_executions_on_process_id_and_job_id"
+  end
+
+  create_table "solid_queue_failed_executions", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.text "error"
+    t.bigint "job_id", null: false
+    t.index ["job_id"], name: "index_solid_queue_failed_executions_on_job_id", unique: true
+  end
+
+  create_table "solid_queue_jobs", force: :cascade do |t|
+    t.string "active_job_id"
+    t.text "arguments"
+    t.string "class_name", null: false
+    t.string "concurrency_key"
+    t.datetime "created_at", null: false
+    t.datetime "finished_at"
+    t.integer "priority", default: 0, null: false
+    t.string "queue_name", null: false
+    t.datetime "scheduled_at"
+    t.datetime "updated_at", null: false
+    t.index ["active_job_id"], name: "index_solid_queue_jobs_on_active_job_id"
+    t.index ["class_name"], name: "index_solid_queue_jobs_on_class_name"
+    t.index ["finished_at"], name: "index_solid_queue_jobs_on_finished_at"
+    t.index ["queue_name", "finished_at"], name: "index_solid_queue_jobs_for_filtering"
+    t.index ["scheduled_at", "finished_at"], name: "index_solid_queue_jobs_for_alerting"
+  end
+
+  create_table "solid_queue_pauses", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.string "queue_name", null: false
+    t.index ["queue_name"], name: "index_solid_queue_pauses_on_queue_name", unique: true
+  end
+
+  create_table "solid_queue_processes", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.string "hostname"
+    t.string "kind", null: false
+    t.datetime "last_heartbeat_at", null: false
+    t.text "metadata"
+    t.string "name", null: false
+    t.integer "pid", null: false
+    t.bigint "supervisor_id"
+    t.index ["last_heartbeat_at"], name: "index_solid_queue_processes_on_last_heartbeat_at"
+    t.index ["name", "supervisor_id"], name: "index_solid_queue_processes_on_name_and_supervisor_id", unique: true
+    t.index ["supervisor_id"], name: "index_solid_queue_processes_on_supervisor_id"
+  end
+
+  create_table "solid_queue_ready_executions", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.bigint "job_id", null: false
+    t.integer "priority", default: 0, null: false
+    t.string "queue_name", null: false
+    t.index ["job_id"], name: "index_solid_queue_ready_executions_on_job_id", unique: true
+    t.index ["priority", "job_id"], name: "index_solid_queue_poll_all"
+    t.index ["queue_name", "priority", "job_id"], name: "index_solid_queue_poll_by_queue"
+  end
+
+  create_table "solid_queue_recurring_executions", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.bigint "job_id", null: false
+    t.datetime "run_at", null: false
+    t.string "task_key", null: false
+    t.index ["job_id"], name: "index_solid_queue_recurring_executions_on_job_id", unique: true
+    t.index ["task_key", "run_at"], name: "index_solid_queue_recurring_executions_on_task_key_and_run_at", unique: true
+  end
+
+  create_table "solid_queue_recurring_tasks", force: :cascade do |t|
+    t.text "arguments"
+    t.string "class_name"
+    t.string "command", limit: 2048
+    t.datetime "created_at", null: false
+    t.text "description"
+    t.string "key", null: false
+    t.integer "priority", default: 0
+    t.string "queue_name"
+    t.string "schedule", null: false
+    t.boolean "static", default: true, null: false
+    t.datetime "updated_at", null: false
+    t.index ["key"], name: "index_solid_queue_recurring_tasks_on_key", unique: true
+    t.index ["static"], name: "index_solid_queue_recurring_tasks_on_static"
+  end
+
+  create_table "solid_queue_scheduled_executions", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.bigint "job_id", null: false
+    t.integer "priority", default: 0, null: false
+    t.string "queue_name", null: false
+    t.datetime "scheduled_at", null: false
+    t.index ["job_id"], name: "index_solid_queue_scheduled_executions_on_job_id", unique: true
+    t.index ["scheduled_at", "priority", "job_id"], name: "index_solid_queue_dispatch_all"
+  end
+
+  create_table "solid_queue_semaphores", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.datetime "expires_at", null: false
+    t.string "key", null: false
+    t.datetime "updated_at", null: false
+    t.integer "value", default: 1, null: false
+    t.index ["expires_at"], name: "index_solid_queue_semaphores_on_expires_at"
+    t.index ["key", "value"], name: "index_solid_queue_semaphores_on_key_and_value"
+    t.index ["key"], name: "index_solid_queue_semaphores_on_key", unique: true
+  end
+
+  add_foreign_key "solid_queue_blocked_executions", "solid_queue_jobs", column: "job_id", on_delete: :cascade
+  add_foreign_key "solid_queue_claimed_executions", "solid_queue_jobs", column: "job_id", on_delete: :cascade
+  add_foreign_key "solid_queue_failed_executions", "solid_queue_jobs", column: "job_id", on_delete: :cascade
+  add_foreign_key "solid_queue_ready_executions", "solid_queue_jobs", column: "job_id", on_delete: :cascade
+  add_foreign_key "solid_queue_recurring_executions", "solid_queue_jobs", column: "job_id", on_delete: :cascade
+  add_foreign_key "solid_queue_scheduled_executions", "solid_queue_jobs", column: "job_id", on_delete: :cascade
+end

data/db/seeds.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/exe/anima

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/anima/cli"
+
+Anima::CLI.start(ARGV)

data/lib/anima/cli.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Anima
+  class CLI < Thor
+    VALID_ENVIRONMENTS = %w[development test production].freeze
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "install", "Set up ~/.anima/ with databases, credentials, and systemd service"
+    def install
+      require_relative "installer"
+      Installer.new.run
+    end
+
+    desc "start", "Boot Anima (runs pending migrations, then exits)"
+    option :environment, aliases: "-e", default: "development", desc: "Rails environment"
+    def start
+      env = options[:environment]
+      unless VALID_ENVIRONMENTS.include?(env)
+        say "Invalid environment: #{env}. Must be one of: #{VALID_ENVIRONMENTS.join(", ")}", :red
+        exit 1
+      end
+
+      ENV["RAILS_ENV"] = env
+
+      unless File.directory?(File.expand_path("~/.anima"))
+        say "Anima is not installed. Run 'anima install' first.", :red
+        exit 1
+      end
+
+      system(Anima.gem_root.join("bin/rails").to_s, "db:prepare") || abort("db:prepare failed")
+      say "Anima booted successfully (#{env}).", :green
+    end
+
+    desc "tui", "Launch the Anima terminal interface"
+    def tui
+      require "ratatui_ruby"
+      ENV["RAILS_ENV"] ||= "development"
+      require_relative "../../config/environment"
+      ActiveRecord::Tasks::DatabaseTasks.prepare_all
+      TUI::App.new.run
+    end
+
+    desc "version", "Show version"
+    map %w[-v --version] => :version
+    def version
+      require_relative "version"
+      say "anima #{Anima::VERSION}"
+    end
+  end
+end

data/lib/anima/installer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "securerandom"
+require "pathname"
+
+module Anima
+  class Installer
+    DIRECTORIES = %w[
+      db
+      config/credentials
+      log
+      tmp
+      tmp/pids
+      tmp/cache
+    ].freeze
+
+    ANIMA_HOME = Pathname.new(File.expand_path("~/.anima")).freeze
+
+    attr_reader :anima_home
+
+    def initialize(anima_home: ANIMA_HOME)
+      @anima_home = anima_home
+    end
+
+    def run
+      say "Installing Anima to #{anima_home}..."
+      create_directories
+      create_config_file
+      generate_credentials
+      create_systemd_service
+      say "Installation complete. Run 'anima start' to begin."
+    end
+
+    def create_directories
+      DIRECTORIES.each do |dir|
+        path = anima_home.join(dir)
+        next if path.directory?
+
+        FileUtils.mkdir_p(path)
+        say "  created #{path}"
+      end
+    end
+
+    def create_config_file
+      config_path = anima_home.join("config", "anima.yml")
+      return if config_path.exist?
+
+      config_path.write(<<~YAML)
+        # Anima configuration
+        # See https://github.com/hoblin/anima for documentation
+      YAML
+      say "  created #{config_path}"
+    end
+
+    def generate_credentials
+      require "active_support"
+      require "active_support/encrypted_configuration"
+
+      %w[production development test].each do |env|
+        content_path = anima_home.join("config", "credentials", "#{env}.yml.enc")
+        key_path = anima_home.join("config", "credentials", "#{env}.key")
+
+        next if key_path.exist? && content_path.exist?
+
+        key = ActiveSupport::EncryptedFile.generate_key
+        key_path.write(key)
+        File.chmod(0o600, key_path.to_s)
+
+        config = ActiveSupport::EncryptedConfiguration.new(
+          config_path: content_path.to_s,
+          key_path: key_path.to_s,
+          env_key: "RAILS_MASTER_KEY",
+          raise_if_missing_key: true
+        )
+
+        config.write("secret_key_base: #{SecureRandom.hex(64)}\n")
+        File.chmod(0o600, content_path.to_s)
+        say "  created credentials for #{env}"
+      end
+    end
+
+    def create_systemd_service
+      service_dir = Pathname.new(File.expand_path("~/.config/systemd/user"))
+      service_path = service_dir.join("anima.service")
+
+      return if service_path.exist?
+
+      FileUtils.mkdir_p(service_dir)
+      anima_bin = File.join(Gem.bindir, "anima")
+
+      service_path.write(<<~UNIT)
+        [Unit]
+        Description=Anima - Personal AI Agent
+        After=network.target
+
+        [Service]
+        Type=simple
+        ExecStart=#{anima_bin} start
+        Restart=on-failure
+        RestartSec=5
+        Environment=RAILS_ENV=production
+
+        [Install]
+        WantedBy=default.target
+      UNIT
+
+      say "  created #{service_path}"
+      system("systemctl", "--user", "daemon-reload", err: File::NULL, out: File::NULL)
+    end
+
+    private
+
+    def say(message)
+      $stdout.puts message
+    end
+  end
+end

data/lib/anima/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Anima
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/anima.rb

@@ -4,4 +4,8 @@ require_relative "anima/version"
 
 module Anima
   class Error < StandardError; end
+
+  def self.gem_root
+    @gem_root ||= Pathname.new(File.expand_path("..", __dir__))
+  end
 end

data/lib/events/agent_message.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Events
+  class AgentMessage < Base
+    TYPE = "agent_message"
+
+    def type
+      TYPE
+    end
+  end
+end

data/lib/events/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Events
+  # Base class for all Anima events. Subclasses must implement #type
+  # returning a string identifier (e.g. "user_message").
+  #
+  # Events are POROs — they carry typed payloads through the event bus.
+  # Persistence is a separate concern handled by ActiveRecord models.
+  #
+  # @abstract Subclass and implement {#type}
+  class Base
+    attr_reader :content, :session_id, :timestamp
+
+    # @param content [String] event payload content
+    # @param session_id [String, nil] optional session identifier
+    def initialize(content:, session_id: nil)
+      @content = content
+      @session_id = session_id
+      @timestamp = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+    end
+
+    # @return [String] event type identifier
+    # @raise [NotImplementedError] if subclass does not implement
+    def type
+      raise NotImplementedError, "#{self.class} must implement #type"
+    end
+
+    # @return [String] namespaced event name for Rails.event (e.g. "anima.user_message")
+    def event_name
+      "#{Bus::NAMESPACE}.#{type}"
+    end
+
+    # @return [Hash] serialized event payload
+    def to_h
+      {type: type, content: content, session_id: session_id, timestamp: timestamp}
+    end
+  end
+end

data/lib/events/bus.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Events
+  # Central event bus built on Rails Structured Event Reporter.
+  # All Anima events flow through here — subsystems emit events and
+  # subscribers react independently without coupling.
+  #
+  # Subscribers must implement the {Subscriber} interface (#emit method).
+  # Rails.event wraps payloads: subscribers receive a Hash with :name,
+  # :payload (the event's to_h), and :timestamp keys.
+  #
+  # @example Emitting an event
+  #   Events::Bus.emit(Events::UserMessage.new(content: "Hello"))
+  #
+  # @example Subscribing
+  #   subscriber = MySubscriber.new  # must implement #emit(event_hash)
+  #   Events::Bus.subscribe(subscriber)
+  module Bus
+    NAMESPACE = "anima"
+
+    class << self
+      # @param event [Events::Base] the event to broadcast
+      def emit(event)
+        Rails.event.notify(event.event_name, event.to_h)
+      end
+
+      # @param subscriber [#emit] object implementing the Subscriber interface
+      # @param filter [Proc] optional filter block passed to Rails.event
+      def subscribe(subscriber, &filter)
+        Rails.event.subscribe(subscriber, &filter)
+      end
+
+      # @param subscriber [#emit] previously subscribed object
+      def unsubscribe(subscriber)
+        Rails.event.unsubscribe(subscriber)
+      end
+    end
+  end
+end

data/lib/events/subscriber.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Events
+  # Interface for event bus subscribers. Include this module and implement
+  # #emit to receive Rails.event notifications.
+  #
+  # The #emit method receives a Hash from Rails Structured Event Reporter:
+  #   { name: "anima.user_message",
+  #     payload: { type: "user_message", content: "hello", ... },
+  #     timestamp: <nanosecond Integer> }
+  #
+  # @example
+  #   class MySubscriber
+  #     include Events::Subscriber
+  #
+  #     def emit(event)
+  #       content = event.dig(:payload, :content)
+  #       # handle event...
+  #     end
+  #   end
+  module Subscriber
+    def emit(event)
+      raise NotImplementedError, "#{self.class} must implement #emit"
+    end
+  end
+end

data/lib/events/subscribers/message_collector.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Events
+  module Subscribers
+    # Collects chat-displayable events in-memory for the current session.
+    # Provides the message list that the TUI renders and the LLM client consumes.
+    #
+    # Only user_message and agent_message events are collected — system_message,
+    # tool_call, and tool_response are internal and not part of the chat display.
+    #
+    # @example
+    #   collector = Events::Subscribers::MessageCollector.new
+    #   Events::Bus.subscribe(collector)
+    #   collector.messages # => [{role: "user", content: "hi"}, ...]
+    class MessageCollector
+      include Events::Subscriber
+
+      DISPLAYABLE_TYPES = %w[user_message agent_message].freeze
+
+      # Maps event types to LLM-compatible role identifiers
+      ROLE_MAP = {
+        "user_message" => "user",
+        "agent_message" => "assistant"
+      }.freeze
+
+      def initialize
+        @messages = []
+        @mutex = Mutex.new
+      end
+
+      # @return [Array<Hash>] thread-safe copy of collected messages
+      def messages
+        @mutex.synchronize { @messages.dup }
+      end
+
+      # Receives a Rails.event notification hash.
+      # @param event [Hash] with :payload containing :type and :content keys
+      def emit(event)
+        type = event.dig(:payload, :type)
+        return unless DISPLAYABLE_TYPES.include?(type)
+
+        content = event.dig(:payload, :content)
+        return if content.nil?
+
+        @mutex.synchronize do
+          @messages << {
+            role: ROLE_MAP.fetch(type),
+            content: content
+          }
+        end
+      end
+
+      # Directly push a pre-built message hash (used for loading persisted events).
+      # @param message [Hash] with :role and :content keys
+      def messages_push(message)
+        @mutex.synchronize { @messages << message }
+      end
+
+      def clear
+        @mutex.synchronize { @messages = [] }
+      end
+    end
+  end
+end

data/lib/events/subscribers/persister.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Events
+  module Subscribers
+    # Persists all events to SQLite as they flow through the event bus.
+    # Each event is written as an Event record belonging to the active session.
+    #
+    # @example
+    #   session = Session.create!
+    #   persister = Events::Subscribers::Persister.new(session)
+    #   Events::Bus.subscribe(persister)
+    class Persister
+      include Events::Subscriber
+
+      attr_reader :session
+
+      def initialize(session)
+        @session = session
+        @mutex = Mutex.new
+      end
+
+      # Receives a Rails.event notification hash and persists it.
+      # @param event [Hash] with :payload containing event data
+      def emit(event)
+        payload = event[:payload]
+        return unless payload.is_a?(Hash)
+
+        event_type = payload[:type]
+        return if event_type.nil?
+
+        @mutex.synchronize do
+          @session.events.create!(
+            event_type: event_type,
+            payload: payload,
+            tool_use_id: payload[:tool_use_id],
+            timestamp: payload[:timestamp] || Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+          )
+        end
+      end
+
+      def session=(new_session)
+        @mutex.synchronize { @session = new_session }
+      end
+    end
+  end
+end

data/lib/events/system_message.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Events
+  class SystemMessage < Base
+    TYPE = "system_message"
+
+    def type
+      TYPE
+    end
+  end
+end

data/lib/events/tool_call.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Events
+  class ToolCall < Base
+    TYPE = "tool_call"
+
+    attr_reader :tool_name, :tool_input, :tool_use_id
+
+    # @param content [String] human-readable description of the tool call
+    # @param tool_name [String] registered tool name (e.g. "web_get")
+    # @param tool_input [Hash] arguments passed to the tool
+    # @param tool_use_id [String] Anthropic-assigned ID for correlating call/result
+    # @param session_id [String, nil] optional session identifier
+    def initialize(content:, tool_name:, tool_input: {}, tool_use_id: nil, session_id: nil)
+      super(content: content, session_id: session_id)
+      @tool_name = tool_name
+      @tool_input = tool_input
+      @tool_use_id = tool_use_id
+    end
+
+    def type
+      TYPE
+    end
+
+    def to_h
+      super.merge(tool_name: tool_name, tool_input: tool_input, tool_use_id: tool_use_id)
+    end
+  end
+end