anima-core 1.0.1 → 1.0.2

data/app/decorators/tool_call_decorator.rb

@@ -5,21 +5,37 @@
 # aggregated tool counter instead. Verbose mode returns tool name
 # and a formatted preview of the input arguments. Debug mode shows
 # full untruncated input as pretty-printed JSON with tool_use_id.
+#
+# Think tool calls are special: "aloud" thoughts are shown in all
+# view modes (with a thought bubble), while "inner" thoughts are
+# visible only in verbose and debug modes.
 class ToolCallDecorator < EventDecorator
-  # @return [nil] tool calls are hidden in basic mode
+  THINK_TOOL = "think"
+
+  # In basic mode, only "aloud" think calls are visible.
+  # All other tool calls are hidden (represented by the tool counter).
+  #
+  # @return [Hash, nil] structured think data for aloud thoughts, nil otherwise
   def render_basic
-    nil
+    return unless think?
+    return unless aloud?
+
+    {role: :think, content: thoughts, visibility: "aloud"}
   end
 
   # @return [Hash] structured tool call data
   #   `{role: :tool_call, tool: String, input: String, timestamp: Integer|nil}`
   def render_verbose
+    return render_think_verbose if think?
+
     {role: :tool_call, tool: payload["tool_name"], input: format_input, timestamp: timestamp}
   end
 
   # @return [Hash] full tool call data with untruncated input and tool_use_id
   #   `{role: :tool_call, tool: String, input: String, tool_use_id: String|nil, timestamp: Integer|nil}`
   def render_debug
+    return render_think_debug if think?
+
     {
       role: :tool_call,
       tool: payload["tool_name"],
@@ -29,8 +45,49 @@ class ToolCallDecorator < EventDecorator
     }
   end
 
+  # Think calls get full text — the agent's reasoning IS the signal.
+  # Other tool calls show tool name + params (compact JSON).
+  # @return [String] transcript line for the analytical brain
+  def render_brain
+    if think?
+      "Think: #{thoughts}"
+    else
+      "Tool call: #{payload["tool_name"]}(#{tool_input.to_json})"
+    end
+  end
+
   private
 
+  def think?
+    payload["tool_name"] == THINK_TOOL
+  end
+
+  def aloud?
+    tool_input.dig("visibility") == "aloud"
+  end
+
+  def thoughts
+    tool_input.dig("thoughts").to_s
+  end
+
+  def tool_input
+    payload["tool_input"] || {}
+  end
+
+  def visibility
+    tool_input.dig("visibility") || "inner"
+  end
+
+  # @return [Hash] think event for verbose mode — both inner and aloud visible
+  def render_think_verbose
+    {role: :think, content: thoughts, visibility: visibility, timestamp: timestamp}
+  end
+
+  # @return [Hash] think event for debug mode — full metadata
+  def render_think_debug
+    {role: :think, content: thoughts, visibility: visibility, tool_use_id: payload["tool_use_id"], timestamp: timestamp}
+  end
+
   # Formats tool input for display, with tool-specific formatting for
   # known tools and generic JSON fallback for others.
   # @return [String] formatted input preview

data/app/decorators/tool_response_decorator.rb

@@ -5,15 +5,22 @@
 # aggregated tool counter instead. Verbose mode returns truncated
 # output with a success/failure indicator. Debug mode shows full
 # untruncated output with tool_use_id and estimated token count.
+#
+# Think tool responses ("OK") are hidden in basic and verbose modes
+# because the value is in the tool_call (the thoughts), not the response.
 class ToolResponseDecorator < EventDecorator
+  THINK_TOOL = "think"
+
   # @return [nil] tool responses are hidden in basic mode
   def render_basic
     nil
   end
 
-  # @return [Hash] structured tool response data
-  #   `{role: :tool_response, content: String, success: Boolean, timestamp: Integer|nil}`
+  # Think responses are hidden in verbose mode — the "OK" adds no information.
+  # @return [Hash, nil] structured tool response data, nil for think responses
   def render_verbose
+    return if think?
+
     {
       role: :tool_response,
       content: truncate_lines(content, max_lines: 3),
@@ -34,4 +41,19 @@ class ToolResponseDecorator < EventDecorator
       timestamp: timestamp
     }.merge(token_info)
   end
+
+  # Think responses ("OK") are noise — excluded from the brain's transcript.
+  # Other tool responses are compressed to success/failure indicators only.
+  # @return [String, nil] ✅ or ❌ indicator, nil for think responses
+  def render_brain
+    return if think?
+
+    (payload["success"] != false) ? "\u2705" : "\u274C"
+  end
+
+  private
+
+  def think?
+    payload["tool_name"] == THINK_TOOL
+  end
 end

data/app/decorators/user_message_decorator.rb

@@ -26,6 +26,12 @@ class UserMessageDecorator < EventDecorator
     render_verbose.merge(token_info)
   end
 
+  # @return [String] user message for the analytical brain, middle-truncated
+  #   if very long (preserves intent at start and conclusion at end)
+  def render_brain
+    "User: #{truncate_middle(content)}"
+  end
+
   private
 
   # @return [Boolean] true when this message is queued but not yet sent to LLM

data/app/jobs/agent_request_job.rb

@@ -64,6 +64,7 @@ class AgentRequestJob < ApplicationJob
     session.schedule_analytical_brain!
   ensure
     release_processing(session_id)
+    clear_interrupt(session_id)
     agent_loop&.finalize
   end
 
@@ -96,6 +97,13 @@ class AgentRequestJob < ApplicationJob
     Session.where(id: session_id).update_all(processing: false)
   end
 
+  # Safety-net clearing of the interrupt flag. The primary clear happens in
+  # {LLM::Client#clear_interrupt!} after handling the interrupt; this ensures
+  # the flag is reset even if the job crashes before reaching that code path.
+  def clear_interrupt(session_id)
+    Session.where(id: session_id, interrupt_requested: true).update_all(interrupt_requested: false)
+  end
+
   # Emits a system message before each retry so the user sees
   # "retrying..." instead of nothing.
   def retry_job(options = {})

data/db/migrate/20260316094817_add_interrupt_requested_to_sessions.rb

@@ -0,0 +1,5 @@
+class AddInterruptRequestedToSessions < ActiveRecord::Migration[8.1]
+  def change
+    add_column :sessions, :interrupt_requested, :boolean, default: false, null: false
+  end
+end

data/lib/agent_loop.rb

@@ -65,7 +65,11 @@ class AgentLoop
   # propagate — designed for callers like {AgentRequestJob} that handle
   # retries and need errors to bubble up.
   #
-  # @return [String] the agent's response text
+  # When the user interrupts, +chat_with_tools+ returns nil. Tool results
+  # are already persisted; no agent message is emitted so the conversation
+  # ends at the interrupted tool result.
+  #
+  # @return [String, nil] the agent's response text, or nil when interrupted
   # @raise [Providers::Anthropic::TransientError] on retryable network/server errors
   # @raise [Providers::Anthropic::AuthenticationError] on auth failures
   def run
@@ -82,6 +86,8 @@ class AgentLoop
     options[:system] = prompt if prompt
 
     response = @client.chat_with_tools(messages, registry: @registry, session_id: @session.id, **options)
+    return unless response
+
     Events::Bus.emit(Events::AgentMessage.new(content: response, session_id: @session.id))
     response
   end
@@ -94,7 +100,7 @@ class AgentLoop
 
   # Tool classes available to all sessions by default.
   # @return [Array<Class<Tools::Base>>]
-  STANDARD_TOOLS = [Tools::Bash, Tools::Read, Tools::Write, Tools::Edit, Tools::WebGet].freeze
+  STANDARD_TOOLS = [Tools::Bash, Tools::Read, Tools::Write, Tools::Edit, Tools::WebGet, Tools::Think].freeze
 
   # Name-to-class mapping for tool restriction validation and registry building.
   # @return [Hash{String => Class<Tools::Base>}]

data/lib/analytical_brain/runner.rb

@@ -129,7 +129,7 @@ module AnalyticalBrain
       events = recent_events
       return [] if events.empty?
 
-      transcript = events.filter_map { |event| format_event(event) }.join("\n")
+      transcript = events.filter_map { |event| EventDecorator.for(event)&.render("brain") }.join("\n")
       content = <<~MSG.strip
         The main session is working on this:
         ```
@@ -151,24 +151,6 @@ module AnalyticalBrain
         .reverse
     end
 
-    # Formats a single event for the analytical brain's transcript.
-    # User/agent messages get 500 chars to preserve conversation context;
-    # tool responses get 200 chars to reduce noise from verbose outputs.
-    #
-    # @param event [Event]
-    # @return [String, nil] formatted line, or nil for unhandled event types
-    def format_event(event)
-      payload = event.payload
-      summary = payload["content"].to_s.truncate(500)
-
-      case event.event_type
-      when "user_message" then "User: #{summary}"
-      when "agent_message" then "Assistant: #{summary}"
-      when "tool_call" then "Tool call: #{payload["tool_name"]}"
-      when "tool_response" then "Tool result: #{summary.truncate(200)}"
-      end
-    end
-
     # Builds the system prompt with current session state, skills catalog,
     # and currently active skills.
     #

data/lib/anima/cli.rb

@@ -20,6 +20,38 @@ module Anima
       Installer.new.run
     end
 
+    desc "update", "Upgrade gem and migrate config"
+    option :migrate_only, type: :boolean, default: false, desc: "Skip gem upgrade, only migrate config"
+    def update
+      unless options[:migrate_only]
+        say "Upgrading anima-core gem..."
+        unless system("gem", "update", "anima-core")
+          say "Gem update failed.", :red
+          exit 1
+        end
+
+        # Re-exec with the updated gem so migration uses the new template.
+        exec(File.join(Gem.bindir, "anima"), "update", "--migrate-only")
+      end
+
+      say "Migrating configuration..."
+      require_relative "config_migrator"
+      result = Anima::ConfigMigrator.new.run
+
+      case result.status
+      when :not_found
+        say "Config file not found. Run 'anima install' first.", :red
+        exit 1
+      when :up_to_date
+        say "Config is already up to date."
+      when :updated
+        result.additions.each do |addition|
+          say "  added [#{addition.section}] #{addition.key} = #{addition.value.inspect}"
+        end
+        say "Config updated. Changes take effect immediately — no restart needed."
+      end
+    end
+
     # Start the Anima brain server (Puma + Solid Queue) via Foreman.
     # Environment precedence: -e flag > RAILS_ENV env var > "development".
     # Requires prior installation (~/.anima must exist).

data/lib/anima/config_migrator.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "toml-rb"
+require "pathname"
+
+module Anima
+  # Merges new default settings into an existing config.toml without
+  # overwriting user-customized values.
+  #
+  # Preserves the user's formatting and comments by extracting text blocks
+  # from the template and appending them to the config file. Missing entire
+  # sections are appended with their separator comments; missing keys within
+  # existing sections are inserted at the end of the section.
+  #
+  # @example
+  #   result = ConfigMigrator.new.run
+  #   result.status    #=> :updated
+  #   result.additions #=> [#<Addition section="paths" key="soul" value="/home/...">]
+  class ConfigMigrator
+    ANIMA_HOME = File.expand_path("~/.anima")
+    TEMPLATE_PATH = File.expand_path("../../templates/config.toml", __dir__).freeze
+
+    # A single config key that was added during migration.
+    # @!attribute [r] section [String] TOML section name
+    # @!attribute [r] key [String] key name within the section
+    # @!attribute [r] value [Object] default value from the template
+    Addition = Data.define(:section, :key, :value)
+
+    # Outcome of a migration run.
+    # @!attribute [r] status [Symbol] :not_found, :up_to_date, or :updated
+    # @!attribute [r] additions [Array<Addition>] keys that were added
+    Result = Data.define(:status, :additions)
+
+    # Section separator pattern used in the template (e.g. "# ─── LLM ───...").
+    SEPARATOR_PATTERN = /^# ─── /
+
+    # @param config_path [String] path to the user's config.toml
+    # @param template_path [String] path to the default config template
+    # @param anima_home [String] expanded path to ~/.anima (for template interpolation)
+    def initialize(config_path: File.join(ANIMA_HOME, "config.toml"),
+      template_path: TEMPLATE_PATH,
+      anima_home: ANIMA_HOME)
+      @config_path = Pathname.new(config_path)
+      @template_path = Pathname.new(template_path)
+      @anima_home = anima_home
+    end
+
+    # Merge missing settings from the template into the user's config.
+    #
+    # @return [Result] status (:not_found, :up_to_date, :updated) and additions list
+    def run
+      return Result.new(status: :not_found, additions: []) unless @config_path.exist?
+
+      template_text = resolve_template
+      template_config = TomlRB.parse(template_text)
+      user_config = TomlRB.load_file(@config_path.to_s)
+
+      additions = find_additions(user_config, template_config)
+      return Result.new(status: :up_to_date, additions: []) if additions.empty?
+
+      apply_additions(additions, template_text)
+      Result.new(status: :updated, additions: additions)
+    end
+
+    private
+
+    # Replace template placeholders with actual paths.
+    def resolve_template
+      File.read(@template_path.to_s).gsub("{{ANIMA_HOME}}") { @anima_home }
+    end
+
+    # Compare user config against template defaults.
+    # Returns additions for keys present in template but absent from user config.
+    def find_additions(user, template)
+      template.flat_map do |section, keys|
+        missing_keys_in_section(user, section, keys)
+      end
+    end
+
+    def missing_keys_in_section(user, section, keys)
+      keys.filter_map do |key, value|
+        next if user.key?(section) && user[section].key?(key)
+
+        Addition.new(section: section, key: key, value: value)
+      end
+    end
+
+    # Write missing settings into the user's config file, preserving existing content.
+    def apply_additions(additions, template_text)
+      user_text = @config_path.read
+      template_blocks = parse_section_blocks(template_text)
+
+      missing_sections, missing_keys = additions.partition do |addition|
+        !user_text.match?(/^\[#{Regexp.escape(addition.section)}\]/)
+      end
+
+      user_text = append_missing_sections(user_text, missing_sections, template_blocks)
+      user_text = insert_missing_keys(user_text, missing_keys, template_text)
+
+      @config_path.write(user_text)
+    end
+
+    def append_missing_sections(user_text, missing_sections, template_blocks)
+      missing_sections.map(&:section).uniq.each do |section|
+        block = template_blocks[section]
+        next unless block
+
+        user_text = "#{user_text.rstrip}\n\n#{block.rstrip}\n"
+      end
+      user_text
+    end
+
+    def insert_missing_keys(user_text, missing_keys, template_text)
+      missing_keys.each do |addition|
+        section = addition.section
+        key_block = extract_key_block(template_text, section, addition.key)
+        next unless key_block
+
+        user_text = insert_key_in_section(user_text, section, key_block)
+      end
+      user_text
+    end
+
+    # Split template into section blocks keyed by TOML section name.
+    # Each block spans from its separator comment to the next separator (exclusive).
+    def parse_section_blocks(template_text)
+      lines = template_text.lines
+      separator_indices = lines.each_index.select { |idx| lines[idx].match?(SEPARATOR_PATTERN) }
+      block_ranges = build_block_ranges(separator_indices, lines.length)
+
+      block_ranges.each_with_object({}) do |(start_idx, end_idx), blocks|
+        block_lines = lines[start_idx..end_idx]
+        section_name = extract_section_name(block_lines)
+        blocks[section_name] = block_lines.join if section_name
+      end
+    end
+
+    # Find the TOML section name (e.g. "llm") within a block of lines.
+    def extract_section_name(block_lines)
+      header = block_lines.find { |line| line.match?(/^\[\w+\]/) }
+      header&.match(/^\[(\w+)\]/)&.[](1)
+    end
+
+    # Build [start, end] pairs from separator indices.
+    def build_block_ranges(separator_indices, total_lines)
+      separator_indices.each_with_index.map do |start_idx, position|
+        next_pos = position + 1
+        end_idx = (next_pos < separator_indices.length) ? separator_indices[next_pos] - 1 : total_lines - 1
+        [start_idx, end_idx]
+      end
+    end
+
+    # Extract a single key and its preceding comment lines from the template.
+    def extract_key_block(template_text, section, key)
+      lines = template_text.lines
+      in_section = false
+
+      lines.each_with_index do |line, line_idx|
+        if line.match?(/^\[#{Regexp.escape(section)}\]/)
+          in_section = true
+        elsif line.match?(/^\[/) && in_section
+          break
+        elsif in_section && line.match?(/^#{Regexp.escape(key)}\s*=/)
+          return build_key_block(lines, line_idx)
+        end
+      end
+      nil
+    end
+
+    # Walk backward from a key line to collect preceding comment lines.
+    def build_key_block(lines, key_idx)
+      comment_start = key_idx
+      scan_idx = key_idx - 1
+      while scan_idx >= 0 && lines[scan_idx].match?(/^#/)
+        comment_start = scan_idx
+        scan_idx -= 1
+      end
+      "\n#{lines[comment_start..key_idx].join}"
+    end
+
+    # Insert a key block at the end of an existing section
+    # (before the next separator comment or EOF).
+    def insert_key_in_section(user_text, section, key_block)
+      lines = user_text.lines
+      insert_at = find_section_end(lines, section)
+      insert_at -= 1 while insert_at > 0 && lines[insert_at - 1].strip.empty?
+
+      lines.insert(insert_at, key_block)
+      lines.join
+    end
+
+    # Find the line index where a section ends (next separator or section header).
+    def find_section_end(lines, section)
+      in_section = false
+      lines.each_with_index do |line, line_idx|
+        if line.match?(/^\[#{Regexp.escape(section)}\]/)
+          in_section = true
+        elsif in_section && (line.match?(SEPARATOR_PATTERN) || line.match?(/^\[/))
+          return line_idx
+        end
+      end
+      lines.length
+    end
+  end
+end

data/lib/anima/installer.rb

@@ -75,124 +75,8 @@ module Anima
       config_path = anima_home.join("config.toml")
       return if config_path.exist?
 
-      config_path.write(<<~TOML)
-        # Anima Configuration
-        #
-        # Edit settings below to customize Anima's behavior.
-        # Changes take effect immediately — no restart needed.
-
-        # ─── LLM ───────────────────────────────────────────────────────
-
-        [llm]
-
-        # Primary model for conversations.
-        model = "claude-sonnet-4-20250514"
-
-        # Lightweight model for fast tasks (e.g. session naming).
-        fast_model = "claude-haiku-4-5"
-
-        # Maximum tokens per LLM response.
-        max_tokens = 8192
-
-        # Maximum consecutive tool execution rounds per request.
-        max_tool_rounds = 25
-
-        # Context window budget — tokens reserved for conversation history.
-        # Set this based on your model's context window minus system prompt.
-        token_budget = 190_000
-
-        # ─── Timeouts (seconds) ─────────────────────────────────────────
-
-        [timeouts]
-
-        # LLM API request timeout.
-        api = 30
-
-        # Shell command execution timeout.
-        command = 30
-
-        # MCP server response timeout.
-        mcp_response = 60
-
-        # Web fetch request timeout.
-        web_request = 10
-
-        # ─── Shell ──────────────────────────────────────────────────────
-
-        [shell]
-
-        # Maximum bytes of command output before truncation.
-        max_output_bytes = 100_000
-
-        # ─── Tools ──────────────────────────────────────────────────────
-
-        [tools]
-
-        # Maximum file size for read/edit operations (bytes).
-        max_file_size = 10_485_760
-
-        # Maximum lines returned by the read tool.
-        max_read_lines = 2_000
-
-        # Maximum bytes returned by the read tool.
-        max_read_bytes = 50_000
-
-        # Maximum bytes from web GET responses.
-        max_web_response_bytes = 100_000
-
-        # ─── Environment ──────────────────────────────────────────────
-
-        [environment]
-
-        # Files to scan for in the working directory (at root and up to project_files_max_depth subdirectories deep).
-        project_files = ["CLAUDE.md", "AGENTS.md", "README.md", "CONTRIBUTING.md"]
-
-        # Maximum directory depth for project file scanning.
-        project_files_max_depth = 3
-
-        # ─── GitHub ─────────────────────────────────────────────────────
-
-        [github]
-
-        # Repository for agent feature requests (owner/repo format).
-        # Falls back to parsing git remote origin when unset.
-        repo = "hoblin/anima"
-
-        # Label applied to agent-created feature request issues.
-        label = "anima-wants"
-
-        # ─── Paths ─────────────────────────────────────────────────────
-
-        [paths]
-
-        # The agent's self-authored identity file.
-        soul = "#{anima_home.join("soul.md")}"
-
-        # ─── Session ────────────────────────────────────────────────────
-
-        [session]
-
-        # Regenerate session name every N messages.
-        name_generation_interval = 30
-
-        # ─── Analytical Brain ─────────────────────────────────────────
-
-        [analytical_brain]
-
-        # Maximum tokens per analytical brain response.
-        # Must accommodate multiple tool calls (rename + goals + skills + ready).
-        max_tokens = 4096
-
-        # Run the analytical brain synchronously before the main agent on user messages.
-        # Ensures activated skills are available for the current response.
-        blocking_on_user_message = true
-
-        # Run the analytical brain asynchronously after the main agent completes.
-        blocking_on_agent_message = false
-
-        # Number of recent events to include in the analytical brain's context window.
-        event_window = 20
-      TOML
+      template = File.read(File.join(TEMPLATE_DIR, "config.toml"))
+      config_path.write(template.gsub("{{ANIMA_HOME}}") { anima_home.to_s })
       say "  created #{config_path}"
     end
 

data/lib/anima/settings.rb

@@ -191,7 +191,7 @@ module Anima
         value = config.dig(section, key)
         if value.nil?
           raise MissingSettingError,
-            "[#{section}] #{key} is not set in #{config_path}. Run `anima install` to create the config file."
+            "[#{section}] #{key} is not set in #{config_path}. Run `anima update` to add missing settings."
         end
         value
       end

data/lib/anima/version.rb

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