ace-llm-providers-cli 0.27.0

data/lib/ace/llm/providers/cli/atoms/session_finders/open_code_session_finder.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module LLM
+    module Providers
+      module CLI
+        module Atoms
+          module SessionFinders
+            # Finds an OpenCode session by scanning its JSON storage.
+            #
+            # OpenCode stores data under ~/.local/share/opencode/storage/
+            # Project mapping: `project/*.json` with `worktree` field matching working_dir
+            # Session: `session/<hash>/*.json` with `id` (ses_ prefix)
+            # Messages: 3-level chain: `message/<sid>/` -> `part/<mid>/` -> text content
+            class OpenCodeSessionFinder
+              DEFAULT_BASE = File.expand_path("~/.local/share/opencode/storage").freeze
+
+              # @param working_dir [String] project directory to match
+              # @param prompt [String] expected first user message
+              # @param base_path [String] override base path for testing
+              # @param max_candidates [Integer] max sessions to scan
+              # @return [Hash, nil] { session_id:, session_path: } or nil
+              def self.call(working_dir:, prompt:, base_path: DEFAULT_BASE, max_candidates: 5)
+                # Verify the working_dir is a known OpenCode project (nil-gate).
+                # OpenCode sessions don't store a project reference, so we can't filter
+                # sessions by project — prompt matching is the primary identification.
+                project_id = find_project_id(base_path, working_dir)
+                return nil unless project_id
+
+                sessions = find_sessions(base_path, max_candidates)
+
+                sessions.each do |session_path, session_data|
+                  session_id = session_data["id"]
+                  next unless session_id
+
+                  if first_message_matches?(base_path, session_id, prompt)
+                    return {session_id: session_id, session_path: session_path}
+                  end
+                end
+
+                nil
+              rescue
+                nil
+              end
+
+              def self.find_project_id(base_path, working_dir)
+                project_dir = File.join(base_path, "project")
+                return nil unless File.directory?(project_dir)
+
+                expanded = File.expand_path(working_dir)
+                Dir.glob(File.join(project_dir, "*.json")).each do |path|
+                  data = JSON.parse(File.read(path))
+                  return data["id"] if data["worktree"] == expanded
+                rescue
+                  next
+                end
+                nil
+              end
+
+              def self.find_sessions(base_path, max_candidates)
+                session_base = File.join(base_path, "session")
+                return [] unless File.directory?(session_base)
+
+                Dir.glob(File.join(session_base, "**", "*.json"))
+                  .sort_by { |f| -File.mtime(f).to_f }
+                  .first(max_candidates)
+                  .filter_map do |path|
+                    data = JSON.parse(File.read(path))
+                    [path, data]
+                  rescue
+                    nil
+                  end
+              end
+
+              def self.first_message_matches?(base_path, session_id, prompt)
+                message_dir = File.join(base_path, "message", session_id)
+                return false unless File.directory?(message_dir)
+
+                # Find the earliest message file
+                message_files = Dir.glob(File.join(message_dir, "*.json"))
+                  .sort_by { |f| File.mtime(f).to_f }
+
+                message_files.each do |msg_path|
+                  msg_data = JSON.parse(File.read(msg_path))
+                  next unless msg_data["role"] == "user"
+
+                  message_id = msg_data["id"]
+                  next unless message_id
+
+                  # Check parts for text content
+                  part_dir = File.join(base_path, "part", message_id)
+                  next unless File.directory?(part_dir)
+
+                  Dir.glob(File.join(part_dir, "*.json")).each do |part_path|
+                    part_data = JSON.parse(File.read(part_path))
+                    text = part_data["text"]
+                    return true if text.is_a?(String) && text.strip == prompt.strip
+                  end
+
+                  return false
+                rescue
+                  next
+                end
+
+                false
+              rescue
+                false
+              end
+
+              private_class_method :find_project_id, :find_sessions, :first_message_matches?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/providers/cli/atoms/session_finders/pi_session_finder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module LLM
+    module Providers
+      module CLI
+        module Atoms
+          module SessionFinders
+            # Finds a Pi agent session by scanning JSONL session files.
+            #
+            # Pi stores sessions under ~/.pi/agent/sessions/<encoded-path>/*.jsonl
+            # Path encoding: replace `/` with `-`, wrap in `--`
+            # Session ID: `type:"session"` entry → `id` field
+            # First user message: `message.role:"user"` + `message.content[0].text`
+            class PiSessionFinder
+              DEFAULT_BASE = File.expand_path("~/.pi/agent/sessions").freeze
+
+              # @param working_dir [String] project directory to match
+              # @param prompt [String] expected first user message
+              # @param base_path [String] override base path for testing
+              # @param max_candidates [Integer] max files to scan
+              # @return [Hash, nil] { session_id:, session_path: } or nil
+              def self.call(working_dir:, prompt:, base_path: DEFAULT_BASE, max_candidates: 5)
+                encoded = encode_path(working_dir)
+                project_dir = File.join(base_path, encoded)
+                return nil unless File.directory?(project_dir)
+
+                candidates = Dir.glob(File.join(project_dir, "*.jsonl"))
+                  .sort_by { |f| -File.mtime(f).to_f }
+                  .first(max_candidates)
+
+                candidates.each do |path|
+                  result = scan_file(path, prompt)
+                  return result if result
+                end
+
+                nil
+              rescue
+                nil
+              end
+
+              def self.encode_path(path)
+                "--#{path.tr("/", "-")}--"
+              end
+
+              def self.scan_file(path, prompt)
+                session_id = nil
+                File.foreach(path) do |line|
+                  entry = JSON.parse(line)
+
+                  # Extract session ID from session-type entry
+                  if entry["type"] == "session" && entry["id"]
+                    session_id = entry["id"]
+                  end
+
+                  # Check for user message match
+                  message = entry["message"]
+                  next unless message.is_a?(Hash) && message["role"] == "user"
+
+                  content = message["content"]
+                  text = if content.is_a?(Array)
+                    content.first&.dig("text")
+                  elsif content.is_a?(String)
+                    content
+                  end
+
+                  if text.is_a?(String) && text.strip == prompt.strip
+                    return {session_id: session_id, session_path: path}
+                  end
+                rescue JSON::ParserError
+                  next
+                end
+                nil
+              rescue
+                nil
+              end
+
+              private_class_method :encode_path, :scan_file
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/providers/cli/atoms/skill_command_rewriter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "command_rewriter"
+require_relative "command_formatters"
+
+module Ace
+  module LLM
+    module Providers
+      module CLI
+        module Atoms
+          # Convenience wrapper for Pi-style skill rewriting.
+          # Delegates to CommandRewriter with PI_FORMATTER.
+          #
+          # Transforms `/name` → `/skill:name` for known skill names,
+          # enabling Pi CLI to discover and invoke skills correctly.
+          class SkillCommandRewriter
+            # Rewrite skill command references in a prompt string.
+            #
+            # @param prompt [String] The prompt text to rewrite
+            # @param skill_names [Array<String>] Known skill names (e.g. ["ace-onboard", "ace-git-commit"])
+            # @return [String] Prompt with `/name` rewritten to `/skill:name`
+            def self.call(prompt, skill_names:)
+              CommandRewriter.call(prompt, skill_names: skill_names, formatter: CommandFormatters::PI_FORMATTER)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/providers/cli/atoms/worktree_dir_resolver.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Ace
+  module LLM
+    module Providers
+      module CLI
+        module Atoms
+          # Detects if the current directory is a git worktree and returns
+          # the common git dir path that needs to be writable for sandbox tools.
+          #
+          # In a worktree, `.git` is a file containing `gitdir: <path>` pointing
+          # to the worktree metadata under the parent repo's `.git/worktrees/`.
+          # The parent `.git/` directory must be writable for index.lock etc.
+          class WorktreeDirResolver
+            # @param working_dir [String] directory to check (default: Dir.pwd)
+            # @return [String, nil] path to common .git dir, or nil if not a worktree
+            def self.call(working_dir: Dir.pwd)
+              new.call(working_dir: working_dir)
+            end
+
+            def call(working_dir: Dir.pwd)
+              dot_git = File.join(working_dir, ".git")
+
+              # If .git is a directory (normal repo) or doesn't exist, not a worktree
+              return nil unless File.file?(dot_git)
+
+              content = File.read(dot_git).strip
+              return nil unless content.start_with?("gitdir:")
+
+              gitdir = content.sub(/\Agitdir:\s*/, "")
+
+              # Resolve relative paths against working_dir
+              gitdir = File.expand_path(gitdir, working_dir) unless gitdir.start_with?("/")
+
+              # Walk up from gitdir to find the common .git/ directory
+              # Typical path: /repo/.git/worktrees/<name> → we want /repo/.git
+              path = gitdir
+              while path != "/" && path != "."
+                basename = File.basename(path)
+                parent = File.dirname(path)
+
+                if basename == "worktrees" && File.directory?(File.join(parent, "refs"))
+                  return parent
+                end
+
+                path = parent
+              end
+
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/providers/cli/claude_code_client.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "shellwords"
+
+require_relative "cli_args_support"
+require_relative "atoms/execution_context"
+
+module Ace
+  module LLM
+    module Providers
+      module CLI
+        # Client for interacting with Claude Code via the Claude CLI
+        # Provides access to Claude Code models through subprocess execution
+        class ClaudeCodeClient < Ace::LLM::Organisms::BaseClient
+          include CliArgsSupport
+
+          # Not used for CLI interaction but required by BaseClient
+          API_BASE_URL = "https://claude.ai"
+          DEFAULT_GENERATION_CONFIG = {}.freeze
+
+          # Provider registration - auto-registers as "claude"
+          def self.provider_name
+            "claude"
+          end
+
+          # Default model (can be overridden by config)
+          DEFAULT_MODEL = "claude-sonnet-4-0"
+
+          def initialize(model: nil, **options)
+            @model = model || DEFAULT_MODEL
+            # Skip normal BaseClient initialization that requires API key
+            @options = options
+            @generation_config = options[:generation_config] || {}
+          end
+
+          # Override to indicate this client doesn't need API credentials
+          def needs_credentials?
+            false
+          end
+
+          # Generate a response from the LLM
+          # @param messages [Array<Hash>] Conversation messages
+          # @param options [Hash] Generation options
+          # @return [Hash] Response with text and metadata
+          def generate(messages, **options)
+            validate_claude_availability!
+
+            # Convert messages to prompt format
+            prompt = format_messages_as_prompt(messages)
+
+            cmd = build_claude_command(options)
+            subprocess_env = options.delete(:subprocess_env)
+            working_dir = Atoms::ExecutionContext.resolve_working_dir(
+              working_dir: options[:working_dir],
+              subprocess_env: subprocess_env
+            )
+            stdout, stderr, status = execute_claude_command(
+              cmd,
+              prompt,
+              subprocess_env: subprocess_env,
+              working_dir: working_dir
+            )
+
+            parse_claude_response(stdout, stderr, status, prompt, options)
+          rescue => e
+            handle_claude_error(e)
+          end
+
+          # List available Claude Code models
+          def list_models
+            # Return models based on what the CLI supports
+            # This is a simplified list - actual models come from YAML config
+            [
+              {id: "claude-opus-4-1", name: "Claude Opus 4.1", description: "Most capable model", context_size: 200_000},
+              {id: "claude-sonnet-4-0", name: "Claude Sonnet 4.0", description: "Balanced model", context_size: 200_000},
+              {id: "claude-3-5-haiku-latest", name: "Claude Haiku 3.5", description: "Fast model", context_size: 200_000}
+            ]
+          end
+
+          private
+
+          def format_messages_as_prompt(messages)
+            # Handle both array of message hashes and string prompt
+            return messages if messages.is_a?(String)
+
+            # Convert array of messages to formatted prompt
+            formatted = messages.map do |msg|
+              role = msg[:role] || msg["role"]
+              content = msg[:content] || msg["content"]
+
+              case role
+              when "system"
+                "System: #{content}"
+              when "user"
+                "User: #{content}"
+              when "assistant"
+                "Assistant: #{content}"
+              else
+                content
+              end
+            end
+
+            formatted.join("\n\n")
+          end
+
+          def claude_available?
+            system("which claude > /dev/null 2>&1")
+          end
+
+          def validate_claude_availability!
+            unless claude_available?
+              raise Ace::LLM::ProviderError, "Claude CLI not found. Install with: npm install -g @anthropic-ai/claude-cli"
+            end
+
+            # Check if Claude is authenticated (quick check)
+            unless claude_authenticated?
+              raise Ace::LLM::AuthenticationError, "Claude authentication required. Run 'claude setup-token' to configure"
+            end
+          end
+
+          def claude_authenticated?
+            # Quick check if Claude can execute (will fail fast if not authenticated)
+            # Using a minimal test that should complete quickly
+            cmd = ["claude", "--version"]
+            stdout, _, status = Open3.capture3(*cmd)
+            status.success? && (stdout.include?("Claude") || stdout.include?("claude"))
+          rescue
+            false
+          end
+
+          def build_claude_command(options)
+            cmd = ["claude"]
+            cmd << "-p"
+
+            # Always use JSON output for consistent parsing
+            cmd << "--output-format" << "json"
+
+            # Add model selection if not default
+            if @model && @model != DEFAULT_MODEL
+              cmd << "--model" << @model
+            end
+
+            # Prompt is passed via stdin to avoid exceeding Linux MAX_ARG_STRLEN
+            # (128KB per-argument limit). System content is already embedded in the
+            # formatted prompt via format_messages_as_prompt.
+
+            # Add max tokens if provided
+            max_tokens = options[:max_tokens] || @generation_config[:max_tokens]
+            if max_tokens
+              cmd << "--max-tokens" << max_tokens.to_s
+            end
+
+            # User CLI args last so they take precedence (last-wins in most CLIs)
+            cmd.concat(normalized_cli_args(options))
+
+            cmd
+          end
+
+          def execute_claude_command(cmd, prompt, subprocess_env: nil, working_dir: nil)
+            timeout_val = @options[:timeout] || 120
+            # Clear CLAUDECODE env var so `claude -p` (non-interactive, one-shot mode)
+            # can run as a subprocess from within a Claude Code session.
+            # The guard was added in Claude Code v2.1.41 to prevent nested interactive
+            # sessions, but -p mode doesn't share session state.
+            env = {"CLAUDECODE" => nil}
+            env.merge!(subprocess_env) if subprocess_env
+            debug_subprocess("spawn timeout=#{timeout_val}s cmd=#{cmd.join(" ")} prompt_bytes=#{prompt.to_s.bytesize}")
+            Molecules::SafeCapture.call(
+              cmd,
+              timeout: timeout_val,
+              stdin_data: prompt.to_s,
+              chdir: working_dir,
+              env: env,
+              provider_name: "Claude"
+            )
+          end
+
+          def parse_claude_response(stdout, stderr, status, prompt, options)
+            unless status.success?
+              error_msg = stderr.empty? ? stdout : stderr
+              raise Ace::LLM::ProviderError, "Claude CLI failed: #{error_msg}"
+            end
+
+            begin
+              # Allow duplicate keys to avoid warnings from Claude CLI output
+              # Some versions of Claude CLI may return JSON with duplicate keys
+              response = JSON.parse(stdout, allow_duplicate_key: true)
+            rescue JSON::ParserError => e
+              raise Ace::LLM::ProviderError, "Failed to parse Claude response: #{e.message}"
+            end
+
+            if response["is_error"]
+              raise Ace::LLM::ProviderError, build_response_error(response)
+            end
+
+            # Extract the text result
+            text = extract_claude_text(response)
+
+            if text.strip.empty?
+              raise Ace::LLM::ProviderError, build_response_error(response)
+            end
+
+            # Build metadata
+            metadata = build_metadata(response, prompt, options)
+
+            # Return hash compatible with ace-llm format
+            {
+              text: text,
+              metadata: metadata
+            }
+          end
+
+          def extract_claude_text(response)
+            direct_result = response["result"]
+            direct_response = response["response"]
+            direct_message = response["message"]
+            direct_text = response["text"]
+
+            candidates = [
+              direct_result,
+              direct_response,
+              direct_message,
+              direct_text,
+              response["content"]
+            ]
+
+            candidates.each do |candidate|
+              text = extract_claude_text_value(candidate)
+              return text unless text.empty?
+            end
+
+            ""
+          end
+
+          def extract_claude_text_value(value)
+            case value
+            when String
+              text = value.to_s.strip
+              return text unless text.empty?
+            when Hash
+              nested_candidates = [
+                value["text"],
+                value["content"],
+                value["response"],
+                value["result"]
+              ]
+
+              nested_candidates.each do |candidate|
+                text = extract_claude_text_value(candidate)
+                return text unless text.empty?
+              end
+
+              if value["messages"].is_a?(Array)
+                text = extract_claude_text_value(value["messages"])
+                return text unless text.empty?
+              end
+
+              if value["parts"].is_a?(Array)
+                text = extract_claude_text_value(value["parts"])
+                return text unless text.empty?
+              end
+
+              if value["choices"].is_a?(Array)
+                text = extract_claude_text_value(value["choices"])
+                return text unless text.empty?
+              end
+            when Array
+              value.each do |entry|
+                text = extract_claude_text_value(entry)
+                return text unless text.empty?
+              end
+            end
+
+            ""
+          end
+
+          def build_metadata(response, prompt, options)
+            usage = response["usage"] || {}
+
+            # Build standard metadata structure
+            metadata = {
+              provider: "claude",
+              model: @model || DEFAULT_MODEL,
+              input_tokens: usage["input_tokens"] || 0,
+              output_tokens: usage["output_tokens"] || 0,
+              total_tokens: (usage["input_tokens"] || 0) + (usage["output_tokens"] || 0),
+              cached_tokens: usage["cache_read_input_tokens"] || 0,
+              finish_reason: response["subtype"] || "success",
+              took: (response["duration_ms"] || 0) / 1000.0,
+              timestamp: Time.now.utc.iso8601
+            }
+
+            # Add cost information if available
+            if response["total_cost_usd"]
+              metadata[:cost] = {
+                input_cost: 0.0, # Claude provides total only
+                output_cost: 0.0,
+                total_cost: response["total_cost_usd"],
+                currency: "USD"
+              }
+            end
+
+            # Add session ID if available
+            metadata[:session_id] = response["session_id"] if response["session_id"]
+
+            # Add any Claude-specific data
+            metadata[:provider_specific] = {
+              uuid: response["uuid"],
+              service_tier: usage["service_tier"],
+              duration_api_ms: response["duration_api_ms"],
+              cache_creation_tokens: usage["cache_creation_input_tokens"]
+            }.compact
+
+            metadata
+          end
+
+          def handle_claude_error(error)
+            # Re-raise the error for proper handling by the base client error flow
+            raise error
+          end
+
+          def build_response_error(response)
+            summary = {
+              "type" => response["type"],
+              "subtype" => response["subtype"],
+              "stop_reason" => response["stop_reason"],
+              "is_error" => response["is_error"],
+              "session_id" => response["session_id"],
+              "duration_ms" => response["duration_ms"]
+            }.compact
+
+            result_preview = response["result"].to_s.strip
+            if response["is_error"] || !result_preview.empty?
+              details = summary.map { |key, value| "#{key}=#{value}" }.join(", ")
+              message = result_preview.empty? ? "no result text provided" : result_preview
+              return "Claude CLI returned an error payload without review text: #{message} (#{details})"
+            end
+
+            details = summary.map { |key, value| "#{key}=#{value}" }.join(", ")
+            if details.empty?
+              "Claude CLI returned empty response (exit 0 but no output text)"
+            else
+              "Claude CLI returned empty response (exit 0, no output text; #{details})"
+            end
+          end
+
+          def debug_subprocess(message)
+            return unless ENV["ACE_LLM_DEBUG_SUBPROCESS"] == "1"
+
+            warn("[ClaudeCodeClient] #{message}")
+          end
+        end
+      end
+    end
+  end
+end