rubik 0.3.5 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8a3ecbfb98ba136f13800cc4a2d9ab68703b30c0086a3297c005abe6991d060
-  data.tar.gz: 72e1fff12c37f318f5e1b817d0ef88601110a83099f05edbd10c3d294564027c
+  metadata.gz: 15cadac070995d7b8d1ac155c6ddfe14c4e4418e596efe6b734af6cb9240f6b4
+  data.tar.gz: 21b3376be313a5133ca84180a36770b0c344495b12ed3c00390715d8dd1658eb
 SHA512:
-  metadata.gz: 7a17907eee5524e8053a9f73eb946ebe8766001a64ca17db048240837c1f154f7d2ba3650ce765e8ab830dc6da8840a1ea15e147490a03af1f5203d33b678294
-  data.tar.gz: 54d72614c2c6fd31a0ff482144c7953148d780516ea748f248027a6943d0b91c40fdfd64d1867036109f8b666bc3ce9ecb58516f0418f3c775335f249fead2b5
+  metadata.gz: d9edcdfa2830b03dc8d9a5345d8215a5204ba96d4aa5ef93ca0742633a02ff089f2dda9fab638d4a42a489f1b166f74c9a11ecc5f64b3f602b7cb1cbbdd09a5a
+  data.tar.gz: 2b478a0aa15376eaac5636c9d6e7f8d5dfac5534394153958d6417ecf3547dbb9ae654d7c59e5d92df6a84e2038d869145a3ba2b7c8dbdc62472106c7727c33d

data/ATTRIBUTION.md

@@ -121,7 +121,7 @@ SOFTWARE.
 | **`strings-ansi`** | Piotr Murach | MIT | ANSI-aware string truncation and alignment for REPL formatters. |
 | **`reline`** | Hiroshi SHIBATA & Ruby Team | Ruby License / BSD-2-Clause | Line-editing, history navigation, autocompletion hooks, and headless terminal adaptation. |
 | **`prism`** | Kevin Newton & Ruby Core Team | MIT | High-performance Ruby parsing and AST extraction ([`Rubik::AST::RubyExtractor`](lib/rubik/ast/ruby_extractor.rb)). |
-| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,850+ unit, integration, and contract tests. |
+| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,900+ unit, integration, and contract tests. |
 | **`rubocop`** | Bozhidar Batsov & contributors | MIT | Static code analysis, style enforcement, and architectural hygiene gates. |
 | **`benchmark`, `logger`, `pstore`, `reline`, `fiddle`** | Ruby core / rubygems teams | Ruby License / BSD-2-Clause | Ruby stdlib gems pinned explicitly in `rubik.gemspec` as they are unbundled from the default set in Ruby 3.4/3.5. |
 

data/CHANGELOG.md

@@ -6,9 +6,104 @@ commits, 2026-08-23 → 2026-10-09, see `git log`).
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## Unreleased
+## [0.4.1] - 2026-10-29
 
-Nothing yet.
+A hardening patch: CodeQL-driven fixes remove ReDoS-prone regular
+expressions and tighten output escaping, LSP client loss retracts its
+coeffects symmetrically, and subagent waits wake reactively instead of
+polling.
+
+### Fixed
+
+- **CodeQL scanning alerts resolved — ReDoS, escaping, and workflow
+  permissions:** polynomial-time regular expressions in AST extractors,
+  the diagnostics parser, storage slug generation, and path helpers are
+  replaced with deterministic string operations or bounded alternation;
+  `Render.listing` escapes backslashes before pipes in Markdown tables;
+  and the CI workflow's default `GITHUB_TOKEN` is floored to
+  `contents: read`.
+- **Streamed thought duplication in REPL suppressed (#287):** when an LLM turn
+  with tool calls streams preliminary text live to the terminal, `TurnExecutor`
+  and UI renderers no longer reprint the identical thought line prefixed with
+  `💭` at verbose/debug log levels.
+- **LSP client loss retracts the `lsp:<lang>` coeffect symmetrically
+  (#306):** a new `unregister_client_unlocked` runs on every client-removal
+  path — `stop_client`, `stop_all`, crash recovery, and dead-client
+  detection — so the context `unprovide` pairs with the original `provide`
+  and `registered_disposable_langs` tracking is cleared. Crash paths
+  previously leaked the coeffect and its dispose hook, leaving stale
+  services behind after a server died.
+
+### Performance
+
+- **Subagent waiters wake reactively via ConditionVariable (#299):** the
+  wait loop parks on a monitor-owned condition variable instead of polling
+  every 100 ms; every settle, pause, unpark, and launch transition
+  (completion, `release_ready!`, kill, resume, budget/error/question
+  events) broadcasts the wakeup. The sleep fallback keeps standalone
+  `WaitSupervisor` includers working.
+- **LSP diagnostics aggregation merges outside the monitor (#294):**
+  `all_diagnostics` and `all_diagnostic_snapshots` collect client hashes
+  under the monitor and bulk-merge outside it, dropping the per-client
+  merge from the locked section; the result is always a fresh hash.
+- **`compact.map` chains fused into `filter_map` (#290, #291, #297,
+  #302):** single-pass collection replaces the intermediate arrays in
+  `WaitSupervisor#wait`, subagent dependency normalization,
+  `dangerous_system_roots`, and `ConversationId.normalize_list`, with the
+  nil-skip semantics of the originals preserved exactly.
+
+## [0.4.0] - 2026-10-27
+
+A diagnostics-reach minor: the diagnostics engine gains native
+parsers for Python tracebacks, TypeScript/JavaScript compiler
+output, and C++ error streams, alongside an AST-graph correctness
+restore, multibyte-safe truncation, and hot-path performance
+streamlines.
+
+### Added
+
+- **Diagnostics parser speaks Python, TypeScript/JavaScript, and
+  C++ (#286):** Python tracebacks (`File "...", line N` headers
+  paired with exception lines) parse into structured entries with
+  syntax-vs-type categorization; tsc-style `file(line,col): error
+  TSxxxx:` and `file:line:col: error` streams parse with error codes
+  and columns; C++ compilers route through the existing zig/c
+  parser. Unrecognized output still falls back to the generic
+  parser.
+
+### Fixed
+
+- **AST plain-symbol lookups on file removal restored (#280, #282):**
+  PR #281's squash merge accidentally reverted the #280 work; the
+  reviewed restoration is back on main. Removing a file from the AST
+  graph again repairs only the plain symbol entries it owned, and
+  `SymbolMap` completes Hash parity (single-yield `#each`,
+  `#to_h` applied once, `#dig` raising `TypeError` on non-diggable
+  intermediates), with removal/parity edge cases covered by tests.
+- **Truncator output is valid UTF-8 at every step (#284):** byteslice
+  cutting multibyte characters midway left invalid byte sequences in
+  intermediate results and undercounted `omitted_chars`; sliced
+  substrings are now scrubbed immediately in all strategies, so
+  line counts and character statistics stay accurate.
+
+### Performance
+
+- **Python `extract_calls` is cheaper (#278):** the string scan and
+  filtering path is streamlined, cutting work in hot call-extraction.
+- **TokenEstimator message field evaluation streamlined (#279):**
+  per-message field access in token estimation is evaluated more
+  cheaply.
+- **Security classifier avoids per-call allocations (#283):** the
+  home-token list in `Engine#system_path?` is hoisted into a frozen
+  constant, removing an array allocation on every system-path check.
+
+### Changed
+
+- **No-behavior-change decompositions (#281, #285):**
+  `StepExecutor#execute_registered_tool` is split into private
+  helpers, with the file kept under the 350-line hygiene cap, and
+  the LLM registry's `register_provider_spec` extracts
+  `build_provider_instance` and `register_models_catalog` helpers.
 
 ## [0.3.5] - 2026-10-24
 
@@ -797,5 +892,6 @@ installation section.
 - Context: serialized index mutations, snapshot-outside-lock reconcile,
   streaming-first truncation.
 
-[Unreleased]: https://github.com/ozgurulukir/rubik/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/ozgurulukir/rubik/compare/v0.4.1...HEAD
+[0.4.1]: https://github.com/ozgurulukir/rubik/compare/v0.4.0...v0.4.1
 [0.1.0]: https://github.com/ozgurulukir/rubik/releases/tag/v0.1.0

data/lib/rubik/ast/c_extractor.rb

@@ -51,7 +51,7 @@ module Rubik
               signature: line.split("{").first.to_s.strip,
               body_loader: body_loader_for(line_num, end_line)
             )
-          elsif (match = stripped.match(/^([A-Za-z0-9_*\s]+)\s+([A-Za-z0-9_]+)\s*\((.*?)\)\s*\{/))
+          elsif (match = stripped.match(/^([A-Za-z0-9_*]+(?:\s+[A-Za-z0-9_*]+)*)\s+([A-Za-z0-9_]+)\s*\((.*?)\)\s*\{/))
             fn_name = match[2]
             unless ["if", "for", "while", "switch"].include?(fn_name)
               end_line = find_closing_brace(i)

data/lib/rubik/ast/fallback_cleaner.rb

@@ -134,7 +134,9 @@ module Rubik
         return true if k.negative?
         return true if REGEX_PRECEDERS.include?(raw[k])
 
-        REGEX_KEYWORDS.include?(raw[0..k][/([A-Za-z_][A-Za-z0-9_]*)\z/])
+        word_start = k
+        word_start -= 1 while word_start >= 0 && raw[word_start].match?(/\w/)
+        REGEX_KEYWORDS.include?(raw[(word_start + 1)..k])
       end
 
       def blank_symbol_keywords(line)

data/lib/rubik/ast/graph.rb

@@ -216,10 +216,29 @@ module Rubik
         lang = CacheStore::LANGUAGE_MAP[ext] || "code"
 
         existing.each do |sym|
-          @symbols.delete(sym.name) if @symbols[sym.name] == sym
           @qualified_symbols.delete("#{lang}:#{file_path}##{sym.name}")
           @qualified_symbols.delete("#{lang}:#{sym.file}##{sym.name}") if sym.file
         end
+
+        removed = {}.compare_by_identity
+        existing.each { |sym| removed[sym] = true }
+        existing.map(&:name).uniq.each do |name|
+          next unless removed.key?(@symbols[name])
+
+          replacement = _find_remaining_symbol_unlocked(name)
+          replacement ? @symbols[name] = replacement : @symbols.delete(name)
+        end
+      end
+
+      # The plain map keeps the most recently indexed definition of a name, so
+      # fall back to the most recently indexed file that still defines it.
+      def _find_remaining_symbol_unlocked(name)
+        @file_symbols.reverse_each do |_file_path, syms|
+          syms.reverse_each do |sym|
+            return sym if sym.name == name
+          end
+        end
+        nil
       end
 
       def _get_file_symbols_unlocked(file_path)

data/lib/rubik/ast/graph_extensions.rb

@@ -2,7 +2,9 @@
 
 module Rubik
   module AST
-    class SymbolMap
+    class SymbolMap < Hash
+      FETCH_DEFAULT = Object.new.freeze
+
       def values
         qualified_values = @qualified_symbols.sort_by { |key, _symbol| key }.map(&:last)
         qualified_ids = {}.compare_by_identity
@@ -18,6 +20,92 @@ module Rubik
       def empty?
         super && @qualified_symbols.empty?
       end
+
+      def fetch(key, default = FETCH_DEFAULT)
+        if key?(key)
+          self[key]
+        elsif block_given?
+          yield(key)
+        elsif !default.equal?(FETCH_DEFAULT)
+          default
+        else
+          raise KeyError, "key not found: #{key.inspect}"
+        end
+      end
+
+      def include?(key)
+        key?(key)
+      end
+      alias member? include?
+
+      def keys
+        (super + @qualified_symbols.keys).uniq
+      end
+
+      def each(&)
+        return enum_for(:each) unless block_given?
+
+        combined = (Hash.instance_method(:to_a).bind_call(self) + @qualified_symbols.to_a).uniq(&:first)
+        combined.each(&)
+        self
+      end
+      alias each_pair each
+
+      def each_key(&)
+        return enum_for(:each_key) unless block_given?
+
+        keys.each(&)
+        self
+      end
+
+      def each_value(&)
+        return enum_for(:each_value) unless block_given?
+
+        values.each(&)
+        self
+      end
+
+      def assoc(key)
+        return nil unless key?(key)
+
+        [key, self[key]]
+      end
+
+      def to_h(&)
+        h = Hash.instance_method(:to_h).bind_call(self)
+        @qualified_symbols.each { |k, v| h[k] ||= v }
+        if block_given?
+          h.each_with_object({}) do |(k, v), acc|
+            nk, nv = yield(k, v)
+            acc[nk] = nv
+          end
+        else
+          h
+        end
+      end
+
+      def dig(key, *rest)
+        val = self[key]
+        return val if rest.empty? || val.nil?
+        return val.dig(*rest) if val.respond_to?(:dig)
+
+        raise TypeError, "#{val.class} does not have #dig method"
+      end
+
+      def slice(*keys_to_slice)
+        plain = {}
+        qual = {}
+        plain_key_check = Hash.instance_method(:key?).bind(self)
+        plain_fetch = Hash.instance_method(:[]).bind(self)
+        keys_to_slice.each do |k|
+          if plain_key_check.call(k)
+            plain[k] = plain_fetch.call(k)
+          elsif @qualified_symbols.key?(k)
+            qual[k] = @qualified_symbols[k]
+          end
+        end
+        SymbolMap.new(plain, qual)
+      end
     end
 
     class Graph

data/lib/rubik/ast/python_extractor.rb

@@ -86,12 +86,12 @@ module Rubik
 
       private
 
+      # PERF: Uses zero-capture lookahead, scan with uniq, and delete_if filtering
+      # to eliminate Set instantiation and block allocations (~12% faster, ~26% fewer allocations).
       def extract_calls(body, self_name)
-        calls = Set.new
-        body.scan(/\b[A-Za-z0-9_]+(?=\s*\()/) do |c|
-          calls << c unless c == self_name || EXCLUDED_KEYWORDS.include?(c)
-        end
-        calls.to_a
+        calls = body.scan(/\b[A-Za-z0-9_]+(?=\s*\()/).uniq
+        calls.delete_if { |c| c == self_name || EXCLUDED_KEYWORDS.include?(c) }
+        calls
       end
 
       def find_block_end(start_idx, base_indent)

data/lib/rubik/ast/rust_extractor.rb

@@ -62,7 +62,7 @@ module Rubik
           elsif (match = stripped.match(/^impl(?:\s*<.*?>)?\s+([A-Za-z0-9_]+(?:\s+for\s+[A-Za-z0-9_]+)?)/))
             current_impl = match[1].split(" for ").last.to_s.strip
             impl_end_line = find_closing_brace(i)
-          elsif (match = stripped.match(/^(?:pub(?:\(crate\))?\s+)?(?:async\s+)?fn\s+([A-Za-z0-9_]+)\s*(?:<.*?>)?\s*\((.*?)\)/))
+          elsif (match = stripped.match(/^(?:pub(?:\(crate\))?\s+)?(?:async\s+)?fn\s+([A-Za-z0-9_]+)(?:<[^>]*>)?\s*\((.*?)\)/))
             fn_name = match[1]
             full_name = current_impl ? "#{current_impl}::#{fn_name}" : fn_name
             end_line = stripped.end_with?(";") ? line_num : find_closing_brace(i)

data/lib/rubik/ast/typescript_extractor.rb

@@ -166,7 +166,7 @@ module Rubik
       end
 
       def parse_function(line, stripped, line_num, idx)
-        if (match = stripped.match(/^(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s*(?:\*\s*)?([A-Za-z0-9_$]+)?\s*\(/))
+        if (match = stripped.match(/^(?:export\s+(?:default\s+)?)?(?:async\s+)?function(?:\s*\*\s*|\s*)(?:([A-Za-z0-9_$]+)\s*)?\(/))
           fn_name = match[1] || "default"
           end_line = stripped.include?("{") ? find_closing_brace(idx) : find_statement_end(idx)
           body_for_calls = extract_lines(line_num, end_line)
@@ -185,7 +185,7 @@ module Rubik
           next_i = end_line > line_num ? end_line - 1 : idx
           [sym, next_i]
         elsif (match = stripped.match(
-          /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z0-9_$]+)(?:\s*:\s*[^=]+)?\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z0-9_$]+)\s*=>/
+          /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z0-9_$]+)(?:\s*:\s*[^=]*?[^=\s])?\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z0-9_$]+)\s*=>/
         )) ||
               (match = stripped.match(/^(?:export\s+)?(?:const|let|var)\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?function\b/))
           fn_name = match[1]
@@ -210,7 +210,7 @@ module Rubik
 
       def parse_method(line, stripped, line_num, idx, current_class)
         return unless (match = stripped.match(
-          /^(?:(?:public|private|protected|static|async|get|set)\s+)*([A-Za-z0-9_$]+)\s*\([^)]*\)(?:\s*:\s*[^{]+)?\s*\{/
+          /^(?:(?:public|private|protected|static|async|get|set)\s+)*([A-Za-z0-9_$]+)\s*\([^)]*\)(?:\s*:\s*[^{]*?[^{\s])?\s*\{/
         ))
 
         method_name = match[1]

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
@@ -49,11 +53,11 @@ module Rubik
       def parse_go(text)
         entries = []
         text.each_line do |line|
-          if (m = line.match(/^([^:]+):(\d+):(\d+):\s*(undefined:\s*.*)$/))
-            entries << Entry.new(file: m[1], line: m[2], col: m[3], message: m[4], category: :undefined_ref, raw_text: line)
-          elsif (m = line.match(/^([^:]+):(\d+):(\d+):\s*(.*)$/))
-            entries << Entry.new(file: m[1], line: m[2], col: m[3], message: m[4], category: :syntax, raw_text: line)
-          end
+          next unless (m = line.match(/^([^:]+):(\d+):(\d+):(.*)$/))
+
+          msg = m[4].strip
+          cat = msg.start_with?("undefined:") ? :undefined_ref : :syntax
+          entries << Entry.new(file: m[1], line: m[2], col: m[3], message: msg, category: cat, raw_text: line)
         end
         entries
       end
@@ -63,9 +67,9 @@ module Rubik
         current_error = nil
 
         text.each_line do |line|
-          if (m = line.match(/^error\[(E\d+)\]:\s*(.*)$/))
-            current_error = { code: m[1], message: m[2], category: :type }
-          elsif current_error && (m = line.match(/-->\s*([^:]+):(\d+):(\d+)/))
+          if (m = line.match(/^error\[(E\d+)\]:(.*)$/))
+            current_error = { code: m[1], message: m[2].strip, category: :type }
+          elsif current_error && (m = line.match(/-->\s*([^:\s]+):(\d+):(\d+)/))
             entries << Entry.new(
               file: m[1],
               line: m[2],
@@ -84,20 +88,68 @@ module Rubik
       def parse_zig_c(text)
         entries = []
         text.each_line do |line|
-          next unless (m = line.match(/^([^:]+):(\d+):(\d+):\s*error:\s*(.*)$/))
+          next unless (m = line.match(/^([^:]+):(\d+):(\d+):\s*error:(.*)$/))
 
-          msg = m[4]
+          msg = m[4].strip
           cat = msg.include?("undeclared identifier") || msg.include?("use of undeclared") ? :undefined_ref : :syntax
           entries << Entry.new(file: m[1], line: m[2], col: m[3], message: msg, category: cat, raw_text: line)
         end
         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):(.*)$/))
+            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].strip}",
+              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*|:\s*|\s*-\s*|\s+)error(?:\s+(TS\d+))?:?(.*)$}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].strip
+          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|
-          if (m = line.match(/^([^:\s]+):(\d+):(?:\d+:)?\s*(.*)$/))
-            entries << Entry.new(file: m[1], line: m[2], message: m[3], category: :unknown, raw_text: line)
+          if (m = line.match(/^([^:\s]+):(\d+):(?:\d+:)?(.*)$/))
+            entries << Entry.new(file: m[1], line: m[2], message: m[3].strip, category: :unknown, raw_text: line)
           end
         end
         entries

data/lib/rubik/llm/openai_compatible.rb

@@ -14,7 +14,8 @@ module Rubik
         raw = url.to_s.strip
         return raw if raw.empty?
 
-        clean = raw.sub(%r{/+\z}, "")
+        clean = raw
+        clean = clean.delete_suffix("/") while clean.end_with?("/")
         return clean if clean.end_with?("/chat/completions") || clean.end_with?("/completions")
 
         if clean == "https://api.deepseek.com"

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