aiko 0.1.0

data/lib/aiko/tools/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Aiko
+  module Tools
+    class Base
+      OUTPUT_LIMIT = 50_000
+
+      def initialize(workdir:)
+        @workdir = workdir
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
+      def description
+        raise NotImplementedError
+      end
+
+      def input_schema
+        raise NotImplementedError
+      end
+
+      def call(arguments)
+        raise NotImplementedError
+      end
+
+      def requires_approval?(_arguments)
+        false
+      end
+
+      def approval_message(arguments)
+        "#{name}(#{arguments.inspect})"
+      end
+
+      protected
+
+      attr_reader :workdir
+
+      def resolve_path(relative)
+        resolved = File.expand_path(relative, workdir)
+        unless resolved == workdir || resolved.start_with?(workdir + File::SEPARATOR)
+          raise ToolError, "path escapes the working directory: #{relative}"
+        end
+        resolved
+      end
+
+      def truncate(text, limit = OUTPUT_LIMIT)
+        return text if text.length <= limit
+
+        "#{text[0, limit]}\n[出力が長いため切り詰めました]"
+      end
+    end
+  end
+end

data/lib/aiko/tools/edit_file.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Aiko
+  module Tools
+    class EditFile < Base
+      def name
+        "edit_file"
+      end
+
+      def description
+        "Replace a unique occurrence of old_string with new_string in a file. " \
+          "old_string must match exactly one location in the file; read the file first."
+      end
+
+      def input_schema
+        {
+          "type" => "object",
+          "properties" => {
+            "path" => {
+              "type" => "string",
+              "description" => "File path relative to the working directory"
+            },
+            "old_string" => {
+              "type" => "string",
+              "description" => "Exact text to replace (must be unique in the file)"
+            },
+            "new_string" => {
+              "type" => "string",
+              "description" => "Replacement text"
+            }
+          },
+          "required" => %w[path old_string new_string]
+        }
+      end
+
+      def call(arguments)
+        path = resolve_path(arguments.fetch("path"))
+        return "Error: no such file: #{arguments["path"]}" unless File.file?(path)
+
+        old_string = arguments.fetch("old_string")
+        new_string = arguments.fetch("new_string")
+        content = File.read(path)
+
+        count = count_occurrences(content, old_string)
+        return "Error: old_string not found" if count.zero?
+        return "Error: old_string is not unique (#{count} matches)" if count > 1
+
+        index = content.index(old_string)
+        File.write(path, content[0, index] + new_string + content[(index + old_string.length)..])
+        "Edited #{arguments["path"]}"
+      end
+
+      def requires_approval?(_arguments)
+        true
+      end
+
+      def approval_message(arguments)
+        "edit_file: #{arguments["path"]} を編集します\n--- 置換前 ---\n#{arguments["old_string"]}\n--- 置換後 ---\n#{arguments["new_string"]}"
+      end
+
+      private
+
+      # 正規表現メタ文字を含むold_stringでも誤動作しないよう、プレーン文字列として数える
+      def count_occurrences(content, old_string)
+        return 0 if old_string.empty?
+
+        count = 0
+        index = 0
+        while (index = content.index(old_string, index))
+          count += 1
+          index += 1
+        end
+        count
+      end
+    end
+  end
+end

data/lib/aiko/tools/list_files.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Aiko
+  module Tools
+    class ListFiles < Base
+      EXCLUDED_DIRS = %w[.git node_modules vendor tmp].freeze
+      MAX_ENTRIES = 1_000
+
+      def name
+        "list_files"
+      end
+
+      def description
+        "List files and directories. Directories have a trailing '/'. " \
+          "Set recursive to true to list the whole tree (hidden files and " \
+          "directories like .git/node_modules are skipped when recursive)."
+      end
+
+      def input_schema
+        {
+          "type" => "object",
+          "properties" => {
+            "path" => {
+              "type" => "string",
+              "description" => "Directory path relative to the working directory (default: working directory)"
+            },
+            "recursive" => {
+              "type" => "boolean",
+              "description" => "List entries recursively (default: false)"
+            }
+          },
+          "required" => []
+        }
+      end
+
+      def call(arguments)
+        base = resolve_path(arguments["path"] || ".")
+        return "Error: no such directory: #{arguments["path"]}" unless File.directory?(base)
+
+        entries = arguments["recursive"] ? collect_recursive(base) : collect_flat(base)
+        entries.sort!
+        return "(empty)" if entries.empty?
+
+        if entries.size > MAX_ENTRIES
+          entries = entries.first(MAX_ENTRIES)
+          entries << "[#{MAX_ENTRIES}エントリを超えたため省略しました]"
+        end
+        truncate(entries.join("\n"))
+      end
+
+      private
+
+      def collect_flat(base)
+        Dir.children(base).map do |entry|
+          File.directory?(File.join(base, entry)) ? "#{entry}/" : entry
+        end
+      end
+
+      def collect_recursive(base, prefix = "")
+        entries = []
+        Dir.children(base).each do |entry|
+          next if entry.start_with?(".") || EXCLUDED_DIRS.include?(entry)
+
+          full = File.join(base, entry)
+          relative = prefix.empty? ? entry : "#{prefix}/#{entry}"
+          if File.directory?(full)
+            entries << "#{relative}/"
+            entries.concat(collect_recursive(full, relative))
+          else
+            entries << relative
+          end
+        end
+        entries
+      end
+    end
+  end
+end

data/lib/aiko/tools/read_file.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Aiko
+  module Tools
+    class ReadFile < Base
+      def name
+        "read_file"
+      end
+
+      def description
+        "Read the contents of a text file. Returns the content with line numbers " \
+          "(e.g. \"1: ...\"). Use this before editing a file."
+      end
+
+      def input_schema
+        {
+          "type" => "object",
+          "properties" => {
+            "path" => {
+              "type" => "string",
+              "description" => "File path relative to the working directory"
+            }
+          },
+          "required" => ["path"]
+        }
+      end
+
+      def call(arguments)
+        path = resolve_path(arguments.fetch("path"))
+        return "Error: no such file: #{arguments["path"]}" unless File.exist?(path)
+        return "Error: is a directory: #{arguments["path"]}" if File.directory?(path)
+        return "Error: binary file: #{arguments["path"]}" if binary?(path)
+
+        numbered = File.read(path).each_line.with_index(1).map do |line, i|
+          format("%d: %s", i, line)
+        end.join
+        truncate(numbered)
+      end
+
+      private
+
+      def binary?(path)
+        head = File.binread(path, 8192) || ""
+        head.include?("\x00")
+      end
+    end
+  end
+end

data/lib/aiko/tools/registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Aiko
+  module Tools
+    class Registry
+      def initialize
+        @tools = {}
+      end
+
+      def register(tool)
+        raise ArgumentError, "tool already registered: #{tool.name}" if @tools.key?(tool.name)
+
+        @tools[tool.name] = tool
+      end
+
+      def schemas
+        @tools.values.map do |tool|
+          {
+            "type" => "function",
+            "function" => {
+              "name" => tool.name,
+              "description" => tool.description,
+              "parameters" => tool.input_schema
+            }
+          }
+        end
+      end
+
+      def dispatch(name, arguments, callbacks:)
+        tool = @tools[name]
+        return "Error: unknown tool '#{name}'" unless tool
+
+        if tool.requires_approval?(arguments) && !callbacks.confirm?(tool.approval_message(arguments))
+          return "User declined to run this tool."
+        end
+
+        begin
+          tool.call(arguments)
+        rescue ToolError, SystemCallError => e
+          "Error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/aiko/tools/run_command.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Aiko
+  module Tools
+    class RunCommand < Base
+      DEFAULT_TIMEOUT = 60
+      MAX_TIMEOUT = 600
+
+      def name
+        "run_command"
+      end
+
+      def description
+        "Run a shell command in the working directory and return its combined " \
+          "stdout/stderr with the exit status. Use this to run tests, scripts, " \
+          "or inspect the environment."
+      end
+
+      def input_schema
+        {
+          "type" => "object",
+          "properties" => {
+            "command" => {
+              "type" => "string",
+              "description" => "Shell command to execute"
+            },
+            "timeout" => {
+              "type" => "integer",
+              "description" => "Timeout in seconds (default: 60, max: 600)"
+            }
+          },
+          "required" => ["command"]
+        }
+      end
+
+      def call(arguments)
+        command = arguments.fetch("command")
+        timeout = [(arguments["timeout"] || DEFAULT_TIMEOUT).to_i, MAX_TIMEOUT].min
+        timeout = DEFAULT_TIMEOUT unless timeout.positive?
+
+        output, status = run_with_timeout(command, timeout)
+        return "Error: command timed out after #{timeout} seconds" unless status
+
+        truncate("exit status: #{status.exitstatus}\n--- output ---\n#{output}")
+      end
+
+      def requires_approval?(_arguments)
+        true
+      end
+
+      def approval_message(arguments)
+        "run_command: #{arguments["command"]}"
+      end
+
+      private
+
+      def run_with_timeout(command, timeout)
+        Open3.popen2e(command, chdir: workdir) do |stdin, stdout_err, wait_thread|
+          stdin.close
+          reader = Thread.new { stdout_err.read }
+          if wait_thread.join(timeout)
+            [reader.value, wait_thread.value]
+          else
+            Process.kill("KILL", wait_thread.pid)
+            wait_thread.join
+            [nil, nil]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aiko/tools/search.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Aiko
+  module Tools
+    class Search < Base
+      MAX_MATCHES = 200
+
+      def name
+        "search"
+      end
+
+      def description
+        "Search file contents with a Ruby regular expression (like grep). " \
+          "Returns matching lines as 'path:line_number: line'. " \
+          "Optionally restrict to a subdirectory and/or a filename glob like '*.rb'."
+      end
+
+      def input_schema
+        {
+          "type" => "object",
+          "properties" => {
+            "pattern" => {
+              "type" => "string",
+              "description" => "Ruby regular expression to search for"
+            },
+            "path" => {
+              "type" => "string",
+              "description" => "Directory to search, relative to the working directory (default: working directory)"
+            },
+            "glob" => {
+              "type" => "string",
+              "description" => "Filename glob filter, e.g. '*.rb'"
+            }
+          },
+          "required" => ["pattern"]
+        }
+      end
+
+      def call(arguments)
+        regexp = begin
+          Regexp.new(arguments.fetch("pattern"))
+        rescue RegexpError => e
+          return "Error: invalid regexp: #{e.message}"
+        end
+
+        base = resolve_path(arguments["path"] || ".")
+        return "Error: no such directory: #{arguments["path"]}" unless File.directory?(base)
+
+        matches = search_files(base, regexp, arguments["glob"])
+        return "(no matches)" if matches.empty?
+
+        truncated = matches.size > MAX_MATCHES
+        matches = matches.first(MAX_MATCHES)
+        matches << "[#{MAX_MATCHES}マッチを超えたため省略しました]" if truncated
+        truncate(matches.join("\n"))
+      end
+
+      private
+
+      def search_files(base, regexp, glob)
+        matches = []
+        each_text_file(base) do |path|
+          next if glob && !File.fnmatch?(glob, File.basename(path))
+
+          relative = path.delete_prefix(workdir + File::SEPARATOR)
+          begin
+            File.foreach(path).with_index(1) do |line, number|
+              matches << "#{relative}:#{number}: #{line.chomp}" if regexp.match?(line)
+              break if matches.size > MAX_MATCHES
+            end
+          rescue ArgumentError
+            # 非UTF-8バイト列を含むファイルはスキップ
+          end
+          break if matches.size > MAX_MATCHES
+        end
+        matches
+      end
+
+      def each_text_file(dir, &block)
+        Dir.children(dir).sort.each do |entry|
+          next if entry.start_with?(".") || ListFiles::EXCLUDED_DIRS.include?(entry)
+
+          full = File.join(dir, entry)
+          if File.directory?(full)
+            each_text_file(full, &block)
+          elsif File.file?(full) && !binary?(full)
+            block.call(full)
+          end
+        end
+      end
+
+      def binary?(path)
+        head = File.binread(path, 8192) || ""
+        head.include?("\x00")
+      end
+    end
+  end
+end

data/lib/aiko/tools/write_file.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aiko
+  module Tools
+    class WriteFile < Base
+      def name
+        "write_file"
+      end
+
+      def description
+        "Create a new file or overwrite an existing file with the given content. " \
+          "Parent directories are created automatically."
+      end
+
+      def input_schema
+        {
+          "type" => "object",
+          "properties" => {
+            "path" => {
+              "type" => "string",
+              "description" => "File path relative to the working directory"
+            },
+            "content" => {
+              "type" => "string",
+              "description" => "Full content to write to the file"
+            }
+          },
+          "required" => %w[path content]
+        }
+      end
+
+      def call(arguments)
+        path = resolve_path(arguments.fetch("path"))
+        content = arguments.fetch("content")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+        "Wrote #{content.bytesize} bytes to #{arguments["path"]}"
+      end
+
+      def requires_approval?(_arguments)
+        true
+      end
+
+      def approval_message(arguments)
+        path = resolve_path(arguments.fetch("path"))
+        content = arguments.fetch("content")
+        action = File.exist?(path) ? "上書き" : "新規作成"
+        preview = content.lines.first(5).join
+        "write_file: #{arguments["path"]} を#{action}します（#{content.bytesize} bytes）\n--- 内容（先頭5行） ---\n#{preview}"
+      end
+    end
+  end
+end

data/lib/aiko/ui.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Aiko
+  class UI
+    TOOL_ARGS_WIDTH = 120
+    RESULT_PREVIEW_LINES = 5
+
+    def initialize(input: $stdin, output: $stdout, error: $stderr, auto_approve: false)
+      @input = input
+      @output = output
+      @error = error
+      @auto_approve = auto_approve
+    end
+
+    def on_assistant_text(text)
+      @output.puts(text)
+    end
+
+    def on_request_start
+      return unless @output.tty?
+
+      @output.print(dim("考え中…"))
+      @output.flush
+    end
+
+    def on_request_end
+      return unless @output.tty?
+
+      @output.print("\r\e[K")
+      @output.flush
+    end
+
+    def on_tool_start(name, arguments)
+      args = arguments.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+      line = "⏺ #{bold(name)}(#{args})"
+      line = "#{line[0, TOOL_ARGS_WIDTH]}…" if line.length > TOOL_ARGS_WIDTH
+      @output.puts(line)
+    end
+
+    def on_tool_result(_name, result)
+      lines = result.lines.first(RESULT_PREVIEW_LINES)
+      lines.each { |line| @output.puts(dim("  #{line.chomp}")) }
+    end
+
+    def confirm?(message)
+      return true if @auto_approve
+      return false unless @input.tty?
+
+      @output.puts(message)
+      @output.print("実行しますか？ [y/N] ")
+      answer = @input.gets
+      !answer.nil? && %w[y Y].include?(answer.strip)
+    end
+
+    def show_error(message)
+      @error.puts("Error: #{message}")
+    end
+
+    def puts(text = "")
+      @output.puts(text)
+    end
+
+    private
+
+    def bold(text)
+      @output.tty? ? "\e[1m#{text}\e[0m" : text
+    end
+
+    def dim(text)
+      @output.tty? ? "\e[2m#{text}\e[0m" : text
+    end
+  end
+end

data/lib/aiko/version.rb

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

data/lib/aiko.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "aiko/version"
+require_relative "aiko/errors"
+require_relative "aiko/config"
+require_relative "aiko/tools/base"
+require_relative "aiko/tools/registry"
+require_relative "aiko/tools/read_file"
+require_relative "aiko/tools/write_file"
+require_relative "aiko/tools/edit_file"
+require_relative "aiko/tools/list_files"
+require_relative "aiko/tools/run_command"
+require_relative "aiko/tools/search"
+require_relative "aiko/llm/client"
+require_relative "aiko/llm/response"
+require_relative "aiko/llm/openai_compatible"
+require_relative "aiko/conversation"
+require_relative "aiko/system_prompt"
+require_relative "aiko/agent"
+require_relative "aiko/ui"
+require_relative "aiko/cli"