akaitsume 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de11bca8eff9c9ffcba7f00f11d998f61ad726fa2ec11031e7489e38c4278464
-  data.tar.gz: 259a7c03cd5e11b6b53c56431fe7df0b615b36362b07bf0af520d19b70960091
+  metadata.gz: f3fecc18ed7284344542f94ca9cc13d0489e5165a61ddb054c285f30a6b00c39
+  data.tar.gz: 553b5efd077b266ea0b9962f007ecf0caae5cc4fc06b51ae2bce7c818ececf5c
 SHA512:
-  metadata.gz: 58e94b9fe21a74c9c8365579dd188b0af2fecfcb0ec3abf3f55fa64829dcc33ab78c65dd4948a0d591063777fe2ae750b3145f1cf855d2ddb4bc87f226d29cd8
-  data.tar.gz: fe343f18ce0db6cf82aaea1a2828ac56b985fb7fed6b946dff3d2f5c94cf9c5b2246ece8af7466255deaf4991e7d1f2637a5583ff0265325e6d4834e9a8966c6
+  metadata.gz: 264c20941a3dd343fed396843aab2bac073f5759fafa491ba79fbcfdb86c4c4d97669ffb9700767f2aeee421a9e3c11228635fd05147956dcc653b8611c175f0
+  data.tar.gz: b569bb26ae8b60a6754b4892e4e56bcb88bfa584529f378c685c619272ede11e2bd6d0beb78c7b7c61c9fb87784daac74a22af68db773544831314cff1e260f0

data/README.md

@@ -1,11 +1,12 @@
 # Akaitsume
 
-赤い爪 — A sharp, extensible AI agent framework for Ruby built on the Anthropic SDK.
+赤い爪 — A sharp, extensible AI agent framework for Ruby.
 
 ## Features
 
 - **Provider abstraction** — swap LLM backends without changing agent code (Anthropic built-in, OpenAI/Ollama ready to add)
-- **Tool system** — trait-based tools with auto-discovery: Bash, Files, HTTP, Memory
+- **Tool system** — trait-based tools with auto-discovery and external plugin loading
+- **Security** — dangerous command guard (Bash), SSRF protection (HTTP), path traversal prevention (Files)
 - **Memory backends** — FileStore (default) or SQLite, switchable via config
 - **Session management** — conversation continuity with token/cost tracking
 - **Hooks** — `before_tool`, `after_tool`, `on_response`, `on_error` callbacks
@@ -28,7 +29,8 @@ gem install akaitsume
 ## Quick start
 
 ```sh
-export ANTHROPIC_API_KEY=sk-...
+# Set your API key (or use .env file with dotenv)
+export ANTHROPIC_API_KEY=sk-ant-...
 
 # Single prompt
 akaitsume run "list files in the current directory"
@@ -76,20 +78,22 @@ Config is loaded from YAML, environment variables, or passed directly:
 
 ```yaml
 # config/agent.yml
-model: claude-sonnet-4-20250514
+model: claude-haiku-4-5-20251001
 max_turns: 20
 max_tokens: 8096
 workspace: ~/.akaitsume/workspace
-memory_backend: file        # or "sqlite"
+memory_backend: file          # or "sqlite"
 db_path: ~/.akaitsume/akaitsume.db
 log_level: info
+tool_paths:                   # external plugin directories
+  - ~/.akaitsume/plugins
 ```
 
 ```sh
 akaitsume run "hello" --config config/agent.yml
 ```
 
-Environment: `ANTHROPIC_API_KEY` is required.
+Environment: `ANTHROPIC_API_KEY` is required. Use a `.env` file with `dotenv` for convenience.
 
 ## Architecture
 
@@ -108,49 +112,63 @@ lib/akaitsume/
 │
 ├── provider/
 │   ├── base.rb           # Provider contract (module)
-│   ├── response.rb       # Unified response value object
+│   ├── response.rb       # Immutable response (Data.define)
 │   └── anthropic.rb      # Anthropic SDK wrapper
 │
 ├── tool/
 │   ├── base.rb           # Tool contract (module)
-│   ├── registry.rb       # Tool registry
-│   ├── bash.rb           # Shell execution
+│   ├── registry.rb       # Auto-discovery + plugin loading
+│   ├── bash.rb           # Shell execution (with dangerous command guard)
 │   ├── files.rb          # File operations (with path traversal protection)
-│   ├── http.rb           # HTTP requests via Faraday
+│   ├── http.rb           # HTTP requests (with SSRF protection)
 │   └── memory_tool.rb    # LLM-facing memory read/write/search
 │
 └── memory/
-    ├── base.rb           # Memory contract (module)
+    ├── base.rb           # Memory contract (module) + Memory.build factory
     ├── file_store.rb     # Markdown file backend (default)
     └── sqlite_store.rb   # SQLite backend (opt-in)
 ```
 
 ## Extending
 
-### Custom tool
+### Custom tool (plugin)
+
+Drop a `.rb` file in a `tool_paths` directory:
 
 ```ruby
-class MyTool
-  include Akaitsume::Tool::Base
-
-  tool_name   'weather'
-  description 'Get current weather for a city'
-  input_schema({
-    type: 'object',
-    properties: {
-      city: { type: 'string', description: 'City name' }
-    },
-    required: ['city']
-  })
-
-  def call(input)
-    # Your implementation here
-    "Weather in #{input['city']}: 22C, sunny"
+# ~/.akaitsume/plugins/weather.rb
+module Akaitsume
+  module Tool
+    class Weather
+      include Base
+
+      tool_name   'weather'
+      description 'Get current weather for a city'
+      input_schema({
+        type: 'object',
+        properties: {
+          city: { type: 'string', description: 'City name' }
+        },
+        required: ['city']
+      })
+
+      def call(input)
+        "Weather in #{input['city']}: 22C, sunny"
+      end
+    end
   end
 end
+```
 
-# Register it
-agent = Akaitsume::Agent.new
+```yaml
+# config/agent.yml
+tool_paths:
+  - ~/.akaitsume/plugins
+```
+
+Or register manually:
+
+```ruby
 registry = Akaitsume::Tool::Registry.new
 registry.register(MyTool)
 agent = Akaitsume::Agent.new(tools: registry)
@@ -168,7 +186,7 @@ class OllamaProvider
     # Call Ollama API, return Provider::Response
     Akaitsume::Provider::Response.new(
       content: [...],
-      stop_reason: 'end_turn',
+      stop_reason: :end_turn,
       model: model,
       usage: { input_tokens: 0, output_tokens: 0 }
     )
@@ -202,6 +220,7 @@ agent = Akaitsume::Agent.new(memory: RedisStore.new)
 | `faraday` | HTTP tool |
 | `sqlite3` | SQLite memory backend |
 | `thor` | CLI framework |
+| `dotenv` | `.env` file loading |
 
 ## License
 

data/bin/akaitsume

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'dotenv/load'
 require_relative '../lib/akaitsume'
 
 Akaitsume::CLI.start(ARGV)

data/lib/akaitsume/agent.rb

@@ -10,12 +10,11 @@ module Akaitsume
                    provider: nil, tools: nil, memory: nil, logger: nil)
       @name     = name
       @role     = role
-      @config   = config
+      @config   = config.ensure_directories!
       @provider = provider || Provider::Anthropic.new(api_key: config.api_key)
-      @memory   = memory || build_memory(config, name)
+      @memory   = memory || Memory.build(config, agent_name: name)
       @tools    = tools || Tool::Registry.default_for(config, memory: @memory)
       @logger   = logger || Logger.new(level: config.log_level)
-      init_hooks
     end
 
     # Spawn a sub-agent with its own tools and memory
@@ -26,7 +25,7 @@ module Akaitsume
         config: @config,
         provider: @provider,
         tools: tools,
-        memory: build_memory(@config, name),
+        memory: Memory.build(@config, agent_name: name),
         logger: @logger
       )
     end
@@ -43,19 +42,17 @@ module Akaitsume
       loop do
         raise MaxTurnsError, "Exceeded max_turns (#{@config.max_turns})" if session.turn_count >= @config.max_turns
 
+        session.increment_turn
         response = call_provider(sys, session)
         session.add_assistant(response.content)
         session.track_usage(response)
 
-        if response.tool_use?
-          tool_results = dispatch_tools(response.content)
-          session.add_tool_results(tool_results)
-        else
-          text = extract_text(response.content)
-          fire(:on_response, text)
-          block&.call(text)
-          return text
-        end
+        next dispatch_tool_cycle(response, session) if response.tool_use?
+
+        text = extract_text(response.content)
+        fire(:on_response, text)
+        block&.call(text)
+        return text
       end
     rescue StandardError => e
       fire(:on_error, e)
@@ -64,13 +61,9 @@ module Akaitsume
 
     private
 
-    def build_memory(config, agent_name)
-      case config.memory_backend
-      when 'sqlite'
-        Memory::SqliteStore.new(db_path: config.db_path, agent_name: agent_name)
-      else
-        Memory::FileStore.new(dir: config.memory_dir, agent_name: agent_name)
-      end
+    def dispatch_tool_cycle(response, session)
+      tool_results = dispatch_tools(response.content)
+      session.add_tool_results(tool_results)
     end
 
     def inject_memory_and_prompt(session, prompt)
@@ -110,7 +103,7 @@ module Akaitsume
 
     def dispatch_tools(content_blocks)
       content_blocks.filter_map do |block|
-        next unless block.type == 'tool_use'
+        next unless block.type == :tool_use
 
         tool = @tools[block.name]
 
@@ -134,7 +127,7 @@ module Akaitsume
 
     def extract_text(content_blocks)
       content_blocks
-        .select { |b| b.type == 'text' }
+        .select { |b| b.type == :text }
         .map(&:text)
         .join
     end

data/lib/akaitsume/cli.rb

@@ -47,7 +47,7 @@ module Akaitsume
     desc 'tools', 'List registered tools'
     def tools
       cfg      = load_config
-      memory   = build_memory(cfg)
+      memory   = Memory.build(cfg)
       registry = Tool::Registry.default_for(cfg, memory: memory)
 
       registry.names.each { |n| say "  \u2022 #{n}" }
@@ -60,14 +60,14 @@ module Akaitsume
       desc 'show [AGENT]', 'Show agent memory'
       def show(agent_name = 'akaitsume')
         cfg   = parent_load_config
-        store = parent_build_memory(cfg, agent_name)
+        store = Memory.build(cfg, agent_name: agent_name)
         say store.read || '(empty)'
       end
 
       desc 'search QUERY [AGENT]', 'Search agent memory'
       def search(query, agent_name = 'akaitsume')
         cfg   = parent_load_config
-        store = parent_build_memory(cfg, agent_name)
+        store = Memory.build(cfg, agent_name: agent_name)
         say store.search(query)
       end
 
@@ -76,15 +76,6 @@ module Akaitsume
           path = parent_options[:config]
           path ? Config.load(path: path) : Config.load
         end
-
-        def parent_build_memory(cfg, agent_name = 'akaitsume')
-          case cfg.memory_backend
-          when 'sqlite'
-            Memory::SqliteStore.new(db_path: cfg.db_path, agent_name: agent_name)
-          else
-            Memory::FileStore.new(dir: cfg.memory_dir, agent_name: agent_name)
-          end
-        end
       end
     }
 
@@ -101,15 +92,6 @@ module Akaitsume
         end
       end
 
-      def build_memory(cfg, agent_name = 'akaitsume')
-        case cfg.memory_backend
-        when 'sqlite'
-          Memory::SqliteStore.new(db_path: cfg.db_path, agent_name: agent_name)
-        else
-          Memory::FileStore.new(dir: cfg.memory_dir, agent_name: agent_name)
-        end
-      end
-
       def build_agent
         cfg = load_config
         Agent.new(config: cfg)

data/lib/akaitsume/config.rb

@@ -6,18 +6,20 @@ require 'fileutils'
 module Akaitsume
   class Config
     DEFAULTS = {
-      model: 'claude-opus-4-6',
+      model: 'claude-haiku-4-5-20251001',
       max_turns: 20,
       max_tokens: 8096,
       workspace: Dir.home + '/.akaitsume/workspace',
       memory_dir: Dir.home + '/.akaitsume/memory',
       memory_backend: 'file',
       db_path: Dir.home + '/.akaitsume/akaitsume.db',
-      log_level: 'info'
+      log_level: 'info',
+      tool_paths: []
     }.freeze
 
     attr_reader :model, :max_turns, :max_tokens, :workspace,
-                :memory_dir, :memory_backend, :db_path, :log_level, :api_key
+                :memory_dir, :memory_backend, :db_path, :log_level, :api_key,
+                :tool_paths
 
     def self.load(path: nil)
       file_cfg = path ? YAML.safe_load_file(path, symbolize_names: true) : {}
@@ -35,9 +37,13 @@ module Akaitsume
       @memory_backend = cfg[:memory_backend].to_s
       @db_path        = cfg[:db_path]
       @log_level      = cfg[:log_level]
+      @tool_paths     = Array(cfg[:tool_paths])
+    end
 
+    def ensure_directories!
       FileUtils.mkdir_p(@workspace)
       FileUtils.mkdir_p(@memory_dir)
+      self
     end
   end
 end

data/lib/akaitsume/hooks.rb

@@ -4,22 +4,20 @@ module Akaitsume
   module Hooks
     EVENTS = %i[before_tool after_tool on_response on_error].freeze
 
-    def self.included(base)
-      base.define_method(:init_hooks) do
-        @hooks = EVENTS.each_with_object({}) { |e, h| h[e] = [] }
-      end
-    end
-
     EVENTS.each do |event|
       define_method(event) do |&block|
-        @hooks[event] << block
+        hooks[event] << block
       end
     end
 
     private
 
+    def hooks
+      @hooks ||= EVENTS.to_h { |e| [e, []] }
+    end
+
     def fire(event, *args)
-      @hooks.fetch(event, []).each { |h| h.call(*args) }
+      hooks[event].each { |h| h.call(*args) }
     end
   end
 end

data/lib/akaitsume/memory/file_store.rb

@@ -7,8 +7,6 @@ module Akaitsume
     class FileStore
       include Base
 
-      MEMORY_FILE = 'MEMORY.md'
-
       def initialize(dir:, agent_name: 'agent')
         @path = File.join(dir, "#{agent_name}.md")
         FileUtils.mkdir_p(dir)

data/lib/akaitsume/provider/anthropic.rb

@@ -12,13 +12,15 @@ module Akaitsume
       end
 
       def chat(messages:, system:, tools:, model:, max_tokens:)
-        raw = @client.messages(
+        params = {
           model: model,
           max_tokens: max_tokens,
           system: system,
-          tools: tools,
           messages: messages
-        )
+        }
+        params[:tools] = tools if tools && !tools.empty?
+
+        raw = @client.messages.create(**params)
 
         Response.new(
           content: raw.content,

data/lib/akaitsume/provider/response.rb

@@ -2,18 +2,13 @@
 
 module Akaitsume
   module Provider
-    class Response
-      attr_reader :content, :stop_reason, :model, :usage
-
+    Response = Data.define(:content, :stop_reason, :model, :usage) do
       def initialize(content:, stop_reason:, model:, usage: {})
-        @content     = content
-        @stop_reason = stop_reason
-        @model       = model
-        @usage       = usage
+        super(content: content, stop_reason: stop_reason, model: model, usage: usage)
       end
 
       def tool_use?
-        stop_reason == 'tool_use'
+        stop_reason == :tool_use
       end
 
       def input_tokens

data/lib/akaitsume/session.rb

@@ -19,6 +19,9 @@ module Akaitsume
 
     def add_assistant(content)
       @messages << { role: 'assistant', content: content }
+    end
+
+    def increment_turn
       @metadata[:turns] += 1
     end
 

data/lib/akaitsume/tool/base.rb

@@ -38,9 +38,10 @@ module Akaitsume
         raise NotImplementedError, "#{self.class}#call not implemented"
       end
 
-      # Wraps result into Anthropic tool_result content format
+      # Normalizes input keys to strings and wraps result into Anthropic tool_result content format
       def execute(input)
-        result = call(input)
+        normalized = input.is_a?(Hash) ? input.transform_keys(&:to_s) : input
+        result = call(normalized)
         { type: 'text', text: result.to_s }
       rescue StandardError => e
         { type: 'text', text: "Error: #{e.message}" }

data/lib/akaitsume/tool/bash.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'open3'
+require 'timeout'
 
 module Akaitsume
   module Tool
@@ -28,28 +29,55 @@ module Akaitsume
                      required: ['command']
                    })
 
-      def initialize(workspace:)
+      DANGEROUS_PATTERNS = [
+        %r{\brm\s+-rf\s+[/~]}, # rm -rf / or ~
+        /\bmkfs\b/,
+        %r{\bdd\s+.*of=/dev/},
+        %r{>\s*/dev/sd},
+        /\bshutdown\b/,
+        /\breboot\b/,
+        /\bchmod\s+-R\s+777/,
+        /\bcurl\b.*\|\s*\bsh\b/,   # curl | sh
+        /\bwget\b.*\|\s*\bsh\b/    # wget | sh
+      ].freeze
+
+      def initialize(workspace:, blocked_commands: nil)
         @workspace = workspace
+        @blocked_commands = blocked_commands || DANGEROUS_PATTERNS
       end
 
       def call(input)
-        cmd     = input['command'] || input[:command]
-        timeout = (input['timeout'] || input[:timeout] || 30).to_i
+        cmd     = input['command']
+        timeout = (input['timeout'] || 30).to_i
+
+        if (violation = detect_dangerous(cmd))
+          return "BLOCKED: dangerous command pattern detected (#{violation}). " \
+                 'If this is intentional, use the files tool or modify blocked_commands config.'
+        end
 
-        stdout, stderr, status = Open3.capture3(
-          cmd,
-          chdir: @workspace,
-          timeout: timeout
-        )
+        stdout, stderr, status = Timeout.timeout(timeout) do
+          Open3.capture3(cmd, chdir: @workspace)
+        end
 
         parts = []
         parts << stdout.strip unless stdout.strip.empty?
         parts << "[stderr] #{stderr.strip}" unless stderr.strip.empty?
         parts << "[exit #{status.exitstatus}]" unless status.success?
         parts.empty? ? '(no output)' : parts.join("\n")
+      rescue Timeout::Error
+        "Error: command timed out after #{(input['timeout'] || 30).to_i}s"
       rescue Errno::ENOENT => e
         "Error: #{e.message}"
       end
+
+      private
+
+      def detect_dangerous(cmd)
+        @blocked_commands.each do |pattern|
+          return pattern.source if pattern.match?(cmd)
+        end
+        nil
+      end
     end
   end
 end

data/lib/akaitsume/tool/files.rb

@@ -38,10 +38,10 @@ module Akaitsume
       end
 
       def call(input)
-        action  = input['action'] || input[:action]
-        path    = input['path']   || input[:path]
-        content = input['content'] || input[:content]
-        pattern = input['pattern'] || input[:pattern] || '**/*'
+        action  = input['action']
+        path    = input['path']
+        content = input['content']
+        pattern = input['pattern'] || '**/*'
 
         case action
         when 'read'   then read(path)

data/lib/akaitsume/tool/http.rb

@@ -2,6 +2,8 @@
 
 require 'faraday'
 require 'json'
+require 'resolv'
+require 'uri'
 
 module Akaitsume
   module Tool
@@ -10,7 +12,8 @@ module Akaitsume
 
       tool_name   'http'
       description 'Make HTTP requests. Supports GET, POST, PUT, PATCH, DELETE. ' \
-                  'Returns status code, response headers, and body (truncated to 4KB).'
+                  'Returns status code, response headers, and body (truncated to 4KB). ' \
+                  'Requests to private/internal networks are blocked by default.'
 
       input_schema({
                      type: 'object',
@@ -43,12 +46,31 @@ module Akaitsume
 
       MAX_BODY = 4096
 
+      # CIDR ranges that are blocked by default (private/link-local/loopback)
+      BLOCKED_RANGES = [
+        IPAddr.new('127.0.0.0/8'), # loopback
+        IPAddr.new('10.0.0.0/8'),        # private class A
+        IPAddr.new('172.16.0.0/12'),     # private class B
+        IPAddr.new('192.168.0.0/16'),    # private class C
+        IPAddr.new('169.254.0.0/16'),    # link-local / cloud metadata
+        IPAddr.new('0.0.0.0/8'),         # "this" network
+        IPAddr.new('::1/128'),           # IPv6 loopback
+        IPAddr.new('fc00::/7'),          # IPv6 unique local
+        IPAddr.new('fe80::/10')          # IPv6 link-local
+      ].freeze
+
+      def initialize(blocked_ranges: nil)
+        @blocked_ranges = blocked_ranges || BLOCKED_RANGES
+      end
+
       def call(input)
-        method  = (input['method'] || input[:method]).downcase.to_sym
-        url     = input['url'] || input[:url]
-        headers = input['headers'] || input[:headers] || {}
-        body    = input['body'] || input[:body]
-        timeout = (input['timeout'] || input[:timeout] || 30).to_i
+        method  = input['method'].downcase.to_sym
+        url     = input['url']
+        headers = input['headers'] || {}
+        body    = input['body']
+        timeout = (input['timeout'] || 30).to_i
+
+        validate_url!(url)
 
         conn = Faraday.new do |f|
           f.options.timeout      = timeout
@@ -68,6 +90,29 @@ module Akaitsume
       rescue Faraday::Error => e
         "Error: #{e.class} - #{e.message}"
       end
+
+      private
+
+      def validate_url!(url)
+        uri = URI.parse(url)
+        host = uri.host
+
+        raise 'BLOCKED: invalid URL' unless host
+        raise 'BLOCKED: only http/https allowed' unless %w[http https].include?(uri.scheme)
+
+        # Resolve hostname to IP and check against blocked ranges
+        ips = Resolv.getaddresses(host)
+        raise "BLOCKED: cannot resolve host '#{host}'" if ips.empty?
+
+        ips.each do |ip_str|
+          ip = IPAddr.new(ip_str)
+          if @blocked_ranges.any? { |range| range.include?(ip) }
+            raise "BLOCKED: requests to private/internal networks are not allowed (#{host} -> #{ip_str})"
+          end
+        end
+      rescue URI::InvalidURIError
+        raise 'BLOCKED: malformed URL'
+      end
     end
   end
 end

data/lib/akaitsume/tool/memory_tool.rb

@@ -36,30 +36,25 @@ module Akaitsume
       end
 
       def call(input)
-        action = input['action'] || input[:action]
-
-        case action
+        case input['action']
         when 'read'
           @memory.read || '(empty memory)'
         when 'store'
-          content = input['content'] || input[:content]
-          return 'Error: content is required for store' unless content
+          return 'Error: content is required for store' unless input['content']
 
-          @memory.store(content)
+          @memory.store(input['content'])
           'Stored to memory.'
         when 'search'
-          query = input['query'] || input[:query]
-          return 'Error: query is required for search' unless query
+          return 'Error: query is required for search' unless input['query']
 
-          @memory.search(query)
+          @memory.search(input['query'])
         when 'replace'
-          content = input['content'] || input[:content]
-          return 'Error: content is required for replace' unless content
+          return 'Error: content is required for replace' unless input['content']
 
-          @memory.replace(content)
+          @memory.replace(input['content'])
           'Memory replaced.'
         else
-          "Error: unknown action '#{action}'"
+          "Error: unknown action '#{input['action']}'"
         end
       end
     end

data/lib/akaitsume/tool/registry.rb

@@ -15,7 +15,7 @@ module Akaitsume
 
       def [](name)
         entry = @tools[name] || raise(ToolNotFoundError, "Tool '#{name}' not registered")
-        entry[:klass].new(**entry[:init_args])
+        entry[:instance] ||= entry[:klass].new(**entry[:init_args])
       end
 
       def api_definitions
@@ -26,16 +26,65 @@ module Akaitsume
         @tools.keys
       end
 
-      # Default registry with all built-in tools.
-      # Pass memory: to enable the MemoryTool.
+      # Auto-discover and register all built-in Tool classes.
+      # Resolves constructor args from the provided context.
       def self.default_for(config, memory: nil)
+        context = { workspace: config.workspace, memory: memory }
+
         new.tap do |r|
-          r.register(Akaitsume::Tool::Bash,  workspace: config.workspace)
-          r.register(Akaitsume::Tool::Files, workspace: config.workspace)
-          r.register(Akaitsume::Tool::Http)
-          r.register(Akaitsume::Tool::MemoryTool, memory: memory) if memory
+          discover_tools.each do |klass|
+            args = resolve_args(klass, context)
+            next if args.nil? # skip if required args not available
+
+            r.register(klass, **args)
+          end
+
+          # Load external tools from config paths
+          load_external(config.tool_paths).each do |klass|
+            args = resolve_args(klass, context) || {}
+            r.register(klass, **args)
+          end
+        end
+      end
+
+      # Find all classes in Akaitsume::Tool that include Tool::Base
+      def self.discover_tools
+        Tool.constants
+            .map { |name| Tool.const_get(name) }
+            .select { |klass| klass.is_a?(Class) && klass < Base }
+      end
+
+      # Match a tool's initialize params to the available context
+      def self.resolve_args(klass, context)
+        params = klass.instance_method(:initialize).parameters
+        return {} if params.empty?
+
+        args = {}
+        params.each do |type, name|
+          if context.key?(name)
+            args[name] = context[name]
+          elsif %i[keyreq req].include?(type)
+            return nil # required arg missing — skip this tool
+          end
         end
+        args
       end
+
+      # Load .rb files from external paths, return tool classes defined in them
+      def self.load_external(paths)
+        return [] if paths.empty?
+
+        before = Tool.constants.dup
+        paths.each do |path|
+          Dir.glob(File.join(path, '*.rb')).each { |f| require f }
+        end
+        new_constants = Tool.constants - before
+        new_constants
+          .map { |name| Tool.const_get(name) }
+          .select { |klass| klass.is_a?(Class) && klass < Base }
+      end
+
+      private_class_method :discover_tools, :resolve_args, :load_external
     end
   end
 end

data/lib/akaitsume/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Akaitsume
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/akaitsume.rb

@@ -12,4 +12,16 @@ module Akaitsume
   class MaxTurnsError < Error; end
   class ToolNotFoundError < Error; end
   class ConfigError < Error; end
+
+  module Memory
+    # Factory: builds a memory store based on config
+    def self.build(config, agent_name: 'akaitsume')
+      case config.memory_backend
+      when 'sqlite'
+        SqliteStore.new(db_path: config.db_path, agent_name: agent_name)
+      else
+        FileStore.new(dir: config.memory_dir, agent_name: agent_name)
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: akaitsume
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Mateusz Palak
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -167,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.9
 specification_version: 4
 summary: 赤い爪 — A sharp, extensible AI agent for Ruby
 test_files: []