akaitsume 0.1.0

data/lib/akaitsume/memory/sqlite_store.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'sqlite3'
+
+module Akaitsume
+  module Memory
+    class SqliteStore
+      include Base
+
+      def initialize(db_path:, agent_name: 'agent')
+        @agent = agent_name
+        @db    = SQLite3::Database.new(db_path)
+        @db.results_as_hash = true
+        create_table
+      end
+
+      def read
+        rows = @db.execute(
+          'SELECT content, created_at FROM memories WHERE agent = ? ORDER BY id ASC',
+          [@agent]
+        )
+        return nil if rows.empty?
+
+        rows.map { |r| "## #{r['created_at']}\n#{r['content']}" }.join("\n\n")
+      end
+
+      def store(entry)
+        @db.execute(
+          'INSERT INTO memories (agent, content) VALUES (?, ?)',
+          [@agent, entry.strip]
+        )
+      end
+
+      def replace(content)
+        @db.execute('DELETE FROM memories WHERE agent = ?', [@agent])
+        store(content) unless content.to_s.strip.empty?
+      end
+
+      def search(query)
+        rows = @db.execute(
+          'SELECT content, created_at FROM memories WHERE agent = ? AND content LIKE ? ORDER BY id ASC',
+          [@agent, "%#{query}%"]
+        )
+        return "(no matches for '#{query}')" if rows.empty?
+
+        rows.map { |r| "[#{r['created_at']}] #{r['content']}" }.join("\n")
+      end
+
+      private
+
+      def create_table
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS memories (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            agent      TEXT    NOT NULL,
+            content    TEXT    NOT NULL,
+            created_at TEXT    DEFAULT (datetime('now', 'localtime'))
+          )
+        SQL
+      end
+    end
+  end
+end

data/lib/akaitsume/provider/anthropic.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Provider
+    class Anthropic
+      include Base
+
+      provider_name 'anthropic'
+
+      def initialize(api_key:)
+        @client = ::Anthropic::Client.new(api_key: api_key)
+      end
+
+      def chat(messages:, system:, tools:, model:, max_tokens:)
+        raw = @client.messages(
+          model: model,
+          max_tokens: max_tokens,
+          system: system,
+          tools: tools,
+          messages: messages
+        )
+
+        Response.new(
+          content: raw.content,
+          stop_reason: raw.stop_reason,
+          model: raw.model,
+          usage: {
+            input_tokens: raw.usage.input_tokens,
+            output_tokens: raw.usage.output_tokens
+          }
+        )
+      end
+    end
+  end
+end

data/lib/akaitsume/provider/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Provider
+    module Base
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def provider_name(name = nil)
+          @provider_name = name if name
+          @provider_name || self.name
+        end
+      end
+
+      # Send messages to the LLM and return a Provider::Response.
+      # Must be implemented by each provider.
+      def chat(messages:, system:, tools:, model:, max_tokens:)
+        raise NotImplementedError, "#{self.class}#chat not implemented"
+      end
+    end
+  end
+end

data/lib/akaitsume/provider/response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Provider
+    class Response
+      attr_reader :content, :stop_reason, :model, :usage
+
+      def initialize(content:, stop_reason:, model:, usage: {})
+        @content     = content
+        @stop_reason = stop_reason
+        @model       = model
+        @usage       = usage
+      end
+
+      def tool_use?
+        stop_reason == 'tool_use'
+      end
+
+      def input_tokens
+        usage[:input_tokens] || 0
+      end
+
+      def output_tokens
+        usage[:output_tokens] || 0
+      end
+
+      def total_tokens
+        input_tokens + output_tokens
+      end
+    end
+  end
+end

data/lib/akaitsume/session.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Akaitsume
+  class Session
+    attr_reader :id, :messages, :system_prompt, :metadata
+
+    def initialize(system_prompt: nil)
+      @id            = SecureRandom.hex(8)
+      @messages      = []
+      @system_prompt = system_prompt
+      @metadata      = { turns: 0, input_tokens: 0, output_tokens: 0 }
+    end
+
+    def add_user(content)
+      @messages << { role: 'user', content: content }
+    end
+
+    def add_assistant(content)
+      @messages << { role: 'assistant', content: content }
+      @metadata[:turns] += 1
+    end
+
+    def add_tool_results(results)
+      @messages << { role: 'user', content: results }
+    end
+
+    def track_usage(response)
+      @metadata[:input_tokens]  += response.input_tokens
+      @metadata[:output_tokens] += response.output_tokens
+    end
+
+    def turn_count
+      @metadata[:turns]
+    end
+
+    def total_tokens
+      @metadata[:input_tokens] + @metadata[:output_tokens]
+    end
+  end
+end

data/lib/akaitsume/tool/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Tool
+    module Base
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def tool_name(name = nil)
+          @tool_name = name if name
+          @tool_name || raise(NotImplementedError, "#{self}.tool_name not defined")
+        end
+
+        def description(desc = nil)
+          @description = desc if desc
+          @description || raise(NotImplementedError, "#{self}.description not defined")
+        end
+
+        def input_schema(schema = nil)
+          @input_schema = schema if schema
+          @input_schema || { type: 'object', properties: {}, required: [] }
+        end
+
+        # Returns the tool definition hash for Anthropic API
+        def to_api_definition
+          {
+            name: tool_name,
+            description: description,
+            input_schema: input_schema
+          }
+        end
+      end
+
+      # Instance method — override in each tool
+      def call(input)
+        raise NotImplementedError, "#{self.class}#call not implemented"
+      end
+
+      # Wraps result into Anthropic tool_result content format
+      def execute(input)
+        result = call(input)
+        { type: 'text', text: result.to_s }
+      rescue StandardError => e
+        { type: 'text', text: "Error: #{e.message}" }
+      end
+    end
+  end
+end

data/lib/akaitsume/tool/bash.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Akaitsume
+  module Tool
+    class Bash
+      include Base
+
+      tool_name   'bash'
+      description 'Execute a shell command and return stdout + stderr. ' \
+                  'Use for file operations, running scripts, git commands, etc. ' \
+                  'Commands run in the configured workspace directory.'
+
+      input_schema({
+                     type: 'object',
+                     properties: {
+                       command: {
+                         type: 'string',
+                         description: 'The shell command to execute'
+                       },
+                       timeout: {
+                         type: 'integer',
+                         description: 'Timeout in seconds (default: 30)',
+                         default: 30
+                       }
+                     },
+                     required: ['command']
+                   })
+
+      def initialize(workspace:)
+        @workspace = workspace
+      end
+
+      def call(input)
+        cmd     = input['command'] || input[:command]
+        timeout = (input['timeout'] || input[:timeout] || 30).to_i
+
+        stdout, stderr, status = Open3.capture3(
+          cmd,
+          chdir: @workspace,
+          timeout: timeout
+        )
+
+        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 Errno::ENOENT => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/akaitsume/tool/files.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Tool
+    class Files
+      include Base
+
+      tool_name   'files'
+      description 'Read, write, list, or delete files in the workspace. ' \
+                  'Actions: read, write, append, list, delete.'
+
+      input_schema({
+                     type: 'object',
+                     properties: {
+                       action: {
+                         type: 'string',
+                         enum: %w[read write append list delete],
+                         description: 'Action to perform'
+                       },
+                       path: {
+                         type: 'string',
+                         description: 'Relative path within workspace'
+                       },
+                       content: {
+                         type: 'string',
+                         description: 'Content to write (for write/append actions)'
+                       },
+                       pattern: {
+                         type: 'string',
+                         description: 'Glob pattern for list action (default: **/*)'
+                       }
+                     },
+                     required: ['action']
+                   })
+
+      def initialize(workspace:)
+        @workspace = workspace
+      end
+
+      def call(input)
+        action  = input['action'] || input[:action]
+        path    = input['path']   || input[:path]
+        content = input['content'] || input[:content]
+        pattern = input['pattern'] || input[:pattern] || '**/*'
+
+        case action
+        when 'read'   then read(path)
+        when 'write'  then write(path, content)
+        when 'append' then append(path, content)
+        when 'list'   then list(pattern)
+        when 'delete' then delete(path)
+        else "Unknown action: #{action}"
+        end
+      end
+
+      private
+
+      def full_path(rel)
+        path = File.expand_path(rel, @workspace)
+        raise 'Path traversal denied' unless path.start_with?(@workspace)
+
+        path
+      end
+
+      def read(rel)
+        p = full_path(rel)
+        raise "File not found: #{rel}" unless File.exist?(p)
+
+        File.read(p)
+      end
+
+      def write(rel, content)
+        p = full_path(rel)
+        FileUtils.mkdir_p(File.dirname(p))
+        File.write(p, content.to_s)
+        "Written #{content.to_s.bytesize} bytes to #{rel}"
+      end
+
+      def append(rel, content)
+        p = full_path(rel)
+        FileUtils.mkdir_p(File.dirname(p))
+        File.open(p, 'a') { |f| f.write(content.to_s) }
+        "Appended to #{rel}"
+      end
+
+      def list(pattern)
+        files = Dir.glob(File.join(@workspace, pattern))
+                   .map { |f| f.delete_prefix("#{@workspace}/") }
+                   .reject { |f| File.directory?(File.join(@workspace, f)) }
+        files.empty? ? '(no files)' : files.join("\n")
+      end
+
+      def delete(rel)
+        p = full_path(rel)
+        raise "File not found: #{rel}" unless File.exist?(p)
+
+        File.delete(p)
+        "Deleted #{rel}"
+      end
+    end
+  end
+end

data/lib/akaitsume/tool/http.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module Akaitsume
+  module Tool
+    class Http
+      include Base
+
+      tool_name   'http'
+      description 'Make HTTP requests. Supports GET, POST, PUT, PATCH, DELETE. ' \
+                  'Returns status code, response headers, and body (truncated to 4KB).'
+
+      input_schema({
+                     type: 'object',
+                     properties: {
+                       method: {
+                         type: 'string',
+                         enum: %w[get post put patch delete],
+                         description: 'HTTP method'
+                       },
+                       url: {
+                         type: 'string',
+                         description: 'Full URL to request'
+                       },
+                       headers: {
+                         type: 'object',
+                         description: 'Request headers as key-value pairs'
+                       },
+                       body: {
+                         type: 'string',
+                         description: 'Request body (for POST/PUT/PATCH)'
+                       },
+                       timeout: {
+                         type: 'integer',
+                         description: 'Timeout in seconds (default: 30)',
+                         default: 30
+                       }
+                     },
+                     required: %w[method url]
+                   })
+
+      MAX_BODY = 4096
+
+      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
+
+        conn = Faraday.new do |f|
+          f.options.timeout      = timeout
+          f.options.open_timeout = timeout
+        end
+
+        response = conn.run_request(method, url, body, headers)
+
+        resp_body = response.body.to_s
+        truncated = resp_body.length > MAX_BODY
+
+        parts = []
+        parts << "[#{response.status}]"
+        parts << resp_body[0...MAX_BODY]
+        parts << "... (truncated, #{resp_body.length} bytes total)" if truncated
+        parts.join("\n")
+      rescue Faraday::Error => e
+        "Error: #{e.class} - #{e.message}"
+      end
+    end
+  end
+end

data/lib/akaitsume/tool/memory_tool.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Tool
+    class MemoryTool
+      include Base
+
+      tool_name   'memory'
+      description 'Read, store, and search your long-term memory. ' \
+                  "Use 'store' to remember important facts. " \
+                  "Use 'read' to recall everything. " \
+                  "Use 'search' to find specific information."
+
+      input_schema({
+                     type: 'object',
+                     properties: {
+                       action: {
+                         type: 'string',
+                         enum: %w[read store search replace],
+                         description: 'Memory operation to perform'
+                       },
+                       content: {
+                         type: 'string',
+                         description: 'Content to store or replace (required for store/replace)'
+                       },
+                       query: {
+                         type: 'string',
+                         description: 'Search query (required for search)'
+                       }
+                     },
+                     required: %w[action]
+                   })
+
+      def initialize(memory:)
+        @memory = memory
+      end
+
+      def call(input)
+        action = input['action'] || input[:action]
+
+        case action
+        when 'read'
+          @memory.read || '(empty memory)'
+        when 'store'
+          content = input['content'] || input[:content]
+          return 'Error: content is required for store' unless content
+
+          @memory.store(content)
+          'Stored to memory.'
+        when 'search'
+          query = input['query'] || input[:query]
+          return 'Error: query is required for search' unless query
+
+          @memory.search(query)
+        when 'replace'
+          content = input['content'] || input[:content]
+          return 'Error: content is required for replace' unless content
+
+          @memory.replace(content)
+          'Memory replaced.'
+        else
+          "Error: unknown action '#{action}'"
+        end
+      end
+    end
+  end
+end

data/lib/akaitsume/tool/registry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Akaitsume
+  module Tool
+    class Registry
+      def initialize
+        @tools = {}
+      end
+
+      def register(tool_class, **init_args)
+        name = tool_class.tool_name
+        @tools[name] = { klass: tool_class, init_args: init_args }
+        self
+      end
+
+      def [](name)
+        entry = @tools[name] || raise(ToolNotFoundError, "Tool '#{name}' not registered")
+        entry[:klass].new(**entry[:init_args])
+      end
+
+      def api_definitions
+        @tools.values.map { |e| e[:klass].to_api_definition }
+      end
+
+      def names
+        @tools.keys
+      end
+
+      # Default registry with all built-in tools.
+      # Pass memory: to enable the MemoryTool.
+      def self.default_for(config, memory: nil)
+        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
+        end
+      end
+    end
+  end
+end

data/lib/akaitsume/version.rb

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

data/lib/akaitsume.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'anthropic'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect('cli' => 'CLI')
+loader.setup
+
+module Akaitsume
+  class Error < StandardError; end
+  class MaxTurnsError < Error; end
+  class ToolNotFoundError < Error; end
+  class ConfigError < Error; end
+end