rubik 0.3.4 → 0.4.0

data/lib/rubik/diagnostics/parser.rb

@@ -21,8 +21,12 @@ module Rubik
                     parse_go(text)
                   when :rust
                     parse_rust(text)
-                  when :zig, :c
+                  when :zig, :c, :cpp, :"c++", :cxx
                     parse_zig_c(text)
+                  when :python, :py
+                    parse_python(text)
+                  when :typescript, :javascript, :ts, :js
+                    parse_ts_js(text)
                   else
                     parse_generic(text)
                   end
@@ -93,6 +97,54 @@ module Rubik
         entries
       end
 
+      def parse_python(text)
+        entries = []
+        current_file = nil
+        current_line = nil
+
+        text.each_line do |line|
+          if (m = line.match(/File "([^"]+)", line (\d+)(?:, in .*)?/))
+            current_file = m[1]
+            current_line = m[2].to_i
+          elsif (m = line.match(/^([A-Za-z0-9_]+Error|Exception):\s*(.*)$/))
+            cat = m[1] =~ /\A(?:Syntax|Indentation|Tab)Error\z/ ? :syntax : :type
+            entries << Entry.new(
+              file: current_file,
+              line: current_line,
+              message: "#{m[1]}: #{m[2]}",
+              category: cat,
+              raw_text: line
+            )
+            current_file = nil
+            current_line = nil
+          end
+        end
+        entries.empty? ? parse_generic(text) : entries
+      end
+
+      def parse_ts_js(text)
+        entries = []
+        text.each_line do |line|
+          next unless (m = line.match(%r{^((?:[a-zA-Z]:[\\/])?[^(:\s]+)(?:\((\d+),(\d+)\)|:(\d+):(\d+)):?\s*-?\s*error\s*(TS\d+)?:?\s*(.*)$}i))
+
+          file = m[1]
+          line_num = (m[2] || m[4]).to_i
+          col_num = (m[3] || m[5]).to_i
+          code = m[6]
+          msg = m[7]
+          entries << Entry.new(
+            file: file,
+            line: line_num,
+            col: col_num,
+            code: code,
+            message: msg,
+            category: :syntax,
+            raw_text: line
+          )
+        end
+        entries.empty? ? parse_generic(text) : entries
+      end
+
       def parse_generic(text)
         entries = []
         text.each_line do |line|

data/lib/rubik/llm/anthropic.rb

@@ -56,8 +56,11 @@ module Rubik
         return opts[:api_key] if opts.key?(:api_key) && !opts[:api_key].nil?
         return @api_key if @api_key && !@api_key.to_s.empty?
 
-        env_name = opts[:api_key_env] || @api_key_env || "ANTHROPIC_API_KEY"
-        ENV.fetch(env_name, nil)
+        env_name = opts[:api_key_env]
+        env_name = @api_key_env if env_name.nil? || env_name.to_s.empty?
+        env_name = "ANTHROPIC_API_KEY" if env_name.nil? || env_name.to_s.empty?
+
+        ENV.fetch(env_name.to_s, nil)
       end
 
       def complete(messages, opts = {})

data/lib/rubik/llm/openai_compatible.rb

@@ -50,20 +50,11 @@ module Rubik
       end
 
       def complete(messages, opts = {})
-        resolved_key = opts[:api_key] || @api_key || (ENV.fetch(@api_key_env, nil) if @api_key_env)
         target_model = opts[:model] || @model
         target_endpoint = self.class.normalize_endpoint(opts[:endpoint] || @endpoint)
         messages = Rubik::LLM::MessageSanitizer.normalize(messages)
 
-        req_headers = { "Content-Type" => "application/json" }
-        req_headers["Authorization"] = "Bearer #{resolved_key}" if resolved_key && !resolved_key.empty?
-
-        # Merge custom headers (e.g. OpenRouter HTTP-Referer, X-Title)
-        @headers.each do |k, v|
-          req_headers[k.to_s] = v.to_s
-        end
-        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
-
+        req_headers = build_headers(opts)
         formatted_msgs = format_messages(messages)
         payload = build_payload(target_model, formatted_msgs, opts, stream: false)
 
@@ -79,73 +70,17 @@ module Rubik
           on_retry: opts[:on_retry]
         )
 
-        root_json = res_json["data"].is_a?(Hash) && res_json["data"]["choices"] ? res_json["data"] : res_json
-        msg = root_json.dig("choices", 0, "message") || {}
-        text = msg["content"] || ""
-        thought = msg["reasoning_content"] || msg["reasoning"] || msg["thought"]
-        thought = nil if thought.to_s.empty?
-        usage = root_json["usage"] || res_json["usage"] || {}
-
-        raw_tool_calls = msg["tool_calls"] || []
-        parsed_tool_calls = raw_tool_calls.map do |tc|
-          fn = tc["function"] || {}
-          args = fn["arguments"]
-          malformed = nil
-          if args.is_a?(String)
-            begin
-              parsed = JSON.parse(args)
-              if parsed.is_a?(Hash)
-                args = parsed
-              else
-                malformed = args
-                args = {}
-              end
-            rescue JSON::ParserError
-              # Issue #55 3.4: the degrade carries the rejected payload so
-              # the executor can echo it back to the model in the error row.
-              malformed = args
-              args = {}
-            end
-          elsif !args.is_a?(Hash) && !args.nil?
-            malformed = args.to_s
-            args = {}
-          end
-          row = {
-            "id" => tc["id"] || "call_#{rand(1000..9999)}",
-            "tool" => fn["name"],
-            "args" => args || {}
-          }
-          row["malformed_args"] = malformed if malformed
-          row
-        end
-
-        in_tokens = usage["prompt_tokens"] || usage["input_tokens"] || estimate_tokens(messages.map { |m| m[:content] || m["content"] }.join)
-        out_tokens = usage["completion_tokens"] || usage["output_tokens"] || estimate_tokens(text)
-
-        Response.new(
-          text: text,
-          usage: {
-            input_tokens: in_tokens,
-            output_tokens: out_tokens
-          },
-          raw: res_json,
-          tool_calls: parsed_tool_calls,
-          thought: thought
-        )
+        build_response(res_json, messages)
       end
 
       # Streaming variant. Yields Chunks. Without a block, returns an
       # Enumerator (via `to_enum`) so the caller can chain `.each`.
       def stream_chat(messages, opts = {}, &block)
-        resolved_key = opts[:api_key] || @api_key || (ENV.fetch(@api_key_env, nil) if @api_key_env)
         target_model = opts[:model] || @model
         target_endpoint = self.class.normalize_endpoint(opts[:endpoint] || @endpoint)
         messages = Rubik::LLM::MessageSanitizer.normalize(messages)
 
-        req_headers = { "Content-Type" => "application/json" }
-        req_headers["Authorization"] = "Bearer #{resolved_key}" if resolved_key && !resolved_key.empty?
-        @headers.each { |k, v| req_headers[k.to_s] = v.to_s }
-        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+        req_headers = build_headers(opts)
 
         formatted_msgs = format_messages(messages)
         payload = build_payload(target_model, formatted_msgs, opts, stream: true)
@@ -172,6 +107,86 @@ module Rubik
 
       private
 
+      def build_headers(opts = {})
+        resolved_key = opts[:api_key] || @api_key || (ENV.fetch(@api_key_env, nil) if @api_key_env)
+        req_headers = { "Content-Type" => "application/json" }
+        req_headers["Authorization"] = "Bearer #{resolved_key}" if resolved_key && !resolved_key.empty?
+
+        # Merge custom headers (e.g. OpenRouter HTTP-Referer, X-Title)
+        @headers.each do |k, v|
+          req_headers[k.to_s] = v.to_s
+        end
+        req_headers.merge!(opts[:headers]) if opts[:headers].is_a?(Hash)
+        req_headers
+      end
+
+      def build_response(res_json, messages)
+        root_json = res_json["data"].is_a?(Hash) && res_json["data"]["choices"] ? res_json["data"] : res_json
+        msg = root_json.dig("choices", 0, "message") || {}
+        text = msg["content"] || ""
+        thought = msg["reasoning_content"] || msg["reasoning"] || msg["thought"]
+        thought = nil if thought.to_s.empty?
+        usage = root_json["usage"] || res_json["usage"] || {}
+
+        parsed_tool_calls = parse_tool_calls(msg["tool_calls"] || [])
+        in_tokens, out_tokens = calculate_usage(usage, messages, text)
+
+        Response.new(
+          text: text,
+          usage: {
+            input_tokens: in_tokens,
+            output_tokens: out_tokens
+          },
+          raw: res_json,
+          tool_calls: parsed_tool_calls,
+          thought: thought
+        )
+      end
+
+      def parse_tool_calls(raw_tool_calls)
+        raw_tool_calls.map do |tc|
+          fn = tc["function"] || {}
+          args, malformed = parse_tool_args(fn["arguments"])
+          row = {
+            "id" => tc["id"] || "call_#{rand(1000..9999)}",
+            "tool" => fn["name"],
+            "args" => args || {}
+          }
+          row["malformed_args"] = malformed if malformed
+          row
+        end
+      end
+
+      def parse_tool_args(args)
+        malformed = nil
+        if args.is_a?(String)
+          begin
+            parsed = JSON.parse(args)
+            if parsed.is_a?(Hash)
+              args = parsed
+            else
+              malformed = args
+              args = {}
+            end
+          rescue JSON::ParserError
+            # Issue #55 3.4: the degrade carries the rejected payload so
+            # the executor can echo it back to the model in the error row.
+            malformed = args
+            args = {}
+          end
+        elsif !args.is_a?(Hash) && !args.nil?
+          malformed = args.to_s
+          args = {}
+        end
+        [args, malformed]
+      end
+
+      def calculate_usage(usage, messages, text)
+        in_tokens = usage["prompt_tokens"] || usage["input_tokens"] || estimate_tokens(messages.map { |m| m[:content] || m["content"] }.join)
+        out_tokens = usage["completion_tokens"] || usage["output_tokens"] || estimate_tokens(text)
+        [in_tokens, out_tokens]
+      end
+
       def reasoning_model?(model_name, opts)
         return true if opts.key?(:reasoning_effort)
         return true if model_name.to_s.match?(/\A(o[134](-[a-z0-9]+)?|o1|o3|o4)\b/i)

data/lib/rubik/llm/registry.rb

@@ -98,87 +98,15 @@ module Rubik
       end
 
       def register_provider_spec(p_name, p_spec)
-        type = p_spec["type"].to_s.downcase
         endpoint = p_spec["endpoint"] || p_spec["host"] || p_spec["url"]
-        api_key_env = p_spec["api_key_env"]
-        api_key = p_spec["api_key"]
         global_headers = extract_global_headers(@config)
         spec_headers = p_spec["headers"] || {}
         headers = global_headers.merge(spec_headers)
         models = p_spec["models"] || []
         default_model = p_spec["default_model"] || (models.is_a?(Array) && models.first.is_a?(Hash) ? models.first["name"] : models.first)
 
-        provider_instance = case type
-                            when "openai_compatible", "openai"
-                              OpenAICompatibleProvider.new(
-                                name: p_name,
-                                endpoint: endpoint || "https://api.openai.com/v1/chat/completions",
-                                api_key: api_key,
-                                api_key_env: api_key_env,
-                                headers: headers,
-                                model: default_model || "gpt-4o",
-                                default_context_limit: spec_limit(p_spec, :context),
-                                default_max_output_tokens: spec_limit(p_spec, :output),
-                                tool_native: p_spec.fetch("tool_native", true)
-                              )
-                            when "ollama"
-                              OllamaProvider.new(
-                                name: p_name,
-                                endpoint: endpoint || "http://localhost:11434",
-                                model: default_model || "qwen2.5-coder:7b",
-                                num_ctx: p_spec["num_ctx"],
-                                headers: headers
-                              )
-                            when "anthropic"
-                              AnthropicProvider.new(
-                                name: p_name,
-                                model: default_model || "claude-sonnet-5-5",
-                                # Honor the same api_key / api_key_env that
-                                # openai-compatible specs already forward;
-                                # otherwise Anthropic auth fails silently.
-                                api_key: api_key,
-                                api_key_env: api_key_env,
-                                headers: headers
-                              )
-                            else
-                              # Default fallback to openai_compatible
-                              OpenAICompatibleProvider.new(
-                                name: p_name,
-                                endpoint: endpoint || "http://localhost:8000/v1/chat/completions",
-                                api_key: api_key,
-                                api_key_env: api_key_env,
-                                headers: headers,
-                                model: default_model || "default",
-                                default_context_limit: spec_limit(p_spec, :context),
-                                default_max_output_tokens: spec_limit(p_spec, :output),
-                                tool_native: p_spec.fetch("tool_native", true)
-                              )
-                            end
-
-        @providers[p_name] = provider_instance
-
-        # Register models in catalog
-        return unless models.is_a?(Array)
-
-        models.each do |m_entry|
-          if m_entry.is_a?(Hash)
-            m_name = m_entry["name"]
-            c_limit = m_entry["context_limit"] || m_entry["context_window"] || 32_768
-            @models_catalog["#{p_name}/#{m_name}"] = {
-              provider: p_name,
-              name: m_name,
-              context_limit: c_limit.to_i,
-              endpoint: endpoint
-            }
-          elsif m_entry.is_a?(String)
-            @models_catalog["#{p_name}/#{m_entry}"] = {
-              provider: p_name,
-              name: m_entry,
-              context_limit: 32_768,
-              endpoint: endpoint
-            }
-          end
-        end
+        @providers[p_name] = build_provider_instance(p_name, p_spec, headers, default_model, endpoint)
+        register_models_catalog(p_name, models, endpoint)
       end
 
       def register(provider_name, provider_instance)
@@ -331,6 +259,85 @@ module Rubik
         end
         result
       end
+
+      private
+
+      def build_provider_instance(p_name, p_spec, headers, default_model, endpoint)
+        type = p_spec["type"].to_s.downcase
+        api_key_env = p_spec["api_key_env"]
+        api_key = p_spec["api_key"]
+
+        case type
+        when "openai_compatible", "openai"
+          OpenAICompatibleProvider.new(
+            name: p_name,
+            endpoint: endpoint || "https://api.openai.com/v1/chat/completions",
+            api_key: api_key,
+            api_key_env: api_key_env,
+            headers: headers,
+            model: default_model || "gpt-4o",
+            default_context_limit: spec_limit(p_spec, :context),
+            default_max_output_tokens: spec_limit(p_spec, :output),
+            tool_native: p_spec.fetch("tool_native", true)
+          )
+        when "ollama"
+          OllamaProvider.new(
+            name: p_name,
+            endpoint: endpoint || "http://localhost:11434",
+            model: default_model || "qwen2.5-coder:7b",
+            num_ctx: p_spec["num_ctx"],
+            headers: headers
+          )
+        when "anthropic"
+          AnthropicProvider.new(
+            name: p_name,
+            model: default_model || "claude-sonnet-5-5",
+            # Honor the same api_key / api_key_env that
+            # openai-compatible specs already forward;
+            # otherwise Anthropic auth fails silently.
+            api_key: api_key,
+            api_key_env: api_key_env,
+            headers: headers
+          )
+        else
+          # Default fallback to openai_compatible
+          OpenAICompatibleProvider.new(
+            name: p_name,
+            endpoint: endpoint || "http://localhost:8000/v1/chat/completions",
+            api_key: api_key,
+            api_key_env: api_key_env,
+            headers: headers,
+            model: default_model || "default",
+            default_context_limit: spec_limit(p_spec, :context),
+            default_max_output_tokens: spec_limit(p_spec, :output),
+            tool_native: p_spec.fetch("tool_native", true)
+          )
+        end
+      end
+
+      def register_models_catalog(p_name, models, endpoint)
+        return unless models.is_a?(Array)
+
+        models.each do |m_entry|
+          if m_entry.is_a?(Hash)
+            m_name = m_entry["name"]
+            c_limit = m_entry["context_limit"] || m_entry["context_window"] || 32_768
+            @models_catalog["#{p_name}/#{m_name}"] = {
+              provider: p_name,
+              name: m_name,
+              context_limit: c_limit.to_i,
+              endpoint: endpoint
+            }
+          elsif m_entry.is_a?(String)
+            @models_catalog["#{p_name}/#{m_entry}"] = {
+              provider: p_name,
+              name: m_entry,
+              context_limit: 32_768,
+              endpoint: endpoint
+            }
+          end
+        end
+      end
     end
   end
 end