rubik 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f2d00bb2c72a92d48741df2cb3c3e84fc970a9ce3e4e844722afa58ef59599
-  data.tar.gz: f3314db467118bbd56aa79625f954f5c9e76611c56b5eb5e467d442fa440aa63
+  metadata.gz: a3548e6b569bb11a7c6c6349bca95300d93cd375c65860095ff18d362cd289ed
+  data.tar.gz: 207e5ed22d5180f7b219b546d0322ac2f597703dec1157ec44da48feb899ab1e
 SHA512:
-  metadata.gz: a5c29f5af7119d6b9189e37d39390c6dd2463caa1fd870e49022b92a0ed72481b227616000a84a2e201f26c7a65009f7fcb05ac6591db6ca1b9ecae3f81bc6d4
-  data.tar.gz: 3ab1188c4607f7dbcbe4011111723f530555052497154eaea6c8d47b09dc927bfcfa43b50b88869f2dc8bc1e402c7589a569d59ad584d29b991bfff765292d08
+  metadata.gz: a6b485c11a72537a00fbe813889f74b92e18edaa1445ec59bc3834bf6e56c377cc60ac628f059878e6d3fc0a1e27d4f63fa1f6161bac84513af4b3640a37c4b6
+  data.tar.gz: 228ce20578fc055bde12ffe0883343f21b74a9b499e718c1e953fc40c9e5054d3c21a27f5e3b986890efba08d3ae23ec77a37498fd197e37a3449de5524d0943

data/ATTRIBUTION.md

@@ -54,6 +54,15 @@ SOFTWARE.
   - **Spatial Composability:** Reactive Coeffect Dependency DAG ($\Sigma \vdash C : \tau$) implemented in [`Rubik::Runtime::ComponentFiber`](lib/rubik/runtime/fiber.rb) and [`Rubik::Runtime::Manager`](lib/rubik/runtime/manager.rb).
   - Zero-downtime hot reloading, atomic rollback on activation failure, and leak-free lifecycle management.
 
+### SKILL.state (Structured Execution State)
+- **Paper:** *"SKILL.state: Scalable Long-Horizon Agent Skills"* ([arXiv:2608.26263](https://arxiv.org/abs/2608.26263))
+- **Authors:** Sanket Badhe, Priyanka Tiwari, Jonghyun Chung
+- **Rubik Implementation:**
+  - The structured goal ledger ([`orchestrator/goal_ledger/`](lib/rubik/orchestrator/goal_ledger/), 2026-10-10): the `!goal` loop replaces append-only conversation memory with an explicit, mutable, rev-guarded execution state Σ (objective, tasks, findings, decisions, open questions, environment notes) — the model sees the current state, not an ever-growing history.
+  - Validated JSON-patch intake (RFC 6902 subset) with the `:syntax` / `:schema` / `:conflict` rejection taxonomy and bounded-retry model feedback (`GoalLedger::Patch` / `Schema` / `Validator`).
+  - The paper's world-drift recovery, coded as tri-state FS re-verification: declarative `verify` assertions are re-checked at step boundaries; a failed assertion flips the task to `stale` with an internal rev bump, so the `:conflict` the model then hits IS the drift signal (`GoalLedger::Verifier` / `VerifySpec` / `DriftNote`).
+  - Observation projection: banked tool results compact into per-row `<absorbed_into_ledger>` tombstones while the last K turns stay raw (`GoalLedger::ObservationProjection`).
+
 ---
 
 ## 🌳 3. AST Parsing & Multi-Language Ecosystem
@@ -112,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 1,690+ unit, integration, and contract tests. |
+| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,400+ 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

@@ -10,8 +10,66 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 Nothing yet.
 
+## [0.1.3] - 2026-10-12
+
+A robustness release straight from a field incident: the `!goal` loop
+no longer strands state when the provider fails mid-goal, and the
+redactor gets measurably cheaper on secret-free input.
+
+### Fixed
+
+- **`!goal` survives provider errors (#105):** an api read-timeout
+  `ClientError` escaped the goal handler (only `Interrupt` was
+  rescued), leaving `GoalState` stuck in `:running`, the ledger
+  unfinalized and the session silent while the batch spinner kept
+  cycling with the cursor hidden. One `fail_goal` channel now serves
+  the `:error` return plus `ClientError`/`StandardError` rescues
+  (`Interrupt` still means `:stopped`); both command-dispatch branches
+  kill the leaked spinner instead of masking the real failure; and
+  goal steps record their tool calls to the session like free-text
+  turns.
+
+### Changed
+
+- **Redactor short-circuits secret-free lines (#104):** pre-compiled
+  quick-check constants plus a trigger check before scrubbing cut
+  allocations by ~68% on a mixed redact workload (172,940 -> 54,864
+  objects per 20x2000-line pass) with byte-for-byte output parity;
+  invalid-UTF-8 input stays total (masked/scrubbed) instead of raising
+  ArgumentError.
+
+## [0.1.2] - 2026-10-11
+
+
+The Anthropic correctness release: the provider now speaks the modern
+extended-thinking contract, so pinning any current Claude model works
+instead of failing with HTTP 400.
+
+### Fixed
+
+- **Anthropic provider speaks the modern thinking contract:** the
+  default model pin moves from the stale `claude-3-7-sonnet-20250219`
+  to `claude-sonnet-5-5`, and the extended-thinking payload follows the
+  model line ? 4.6+ and the 5.x/Fable models get the adaptive form
+  (`thinking: {type: "adaptive"}` with an `output_config` effort),
+  3-7-sonnet through the 4.5 line keep the `budget_tokens` math, and
+  pre-thinking lines get nothing attached. 0.1.1 sent the legacy form
+  to every Anthropic model, which Claude 4.7+ rejects with HTTP 400.
+
+### Changed
+
+- Extended thinking auto-enables on every thinking-capable Anthropic
+  model line (previously only claude-3-7-sonnet); `thinking: false`
+  still disables it everywhere and `thinking_budget_ratio` shapes the
+  legacy form only. Requests that carry thinking still force
+  `temperature` to 1.0.
+- README quick start documents the native Anthropic provider
+  (`ANTHROPIC_API_KEY` + `!model anthropic/<model>`) next to the
+  OpenAI-compatible example.
+
 ## [0.1.1] - 2026-10-11
 
+
 The Linux surface release: CI now proves Linux on Ruby 3.4 and 4.0
 (`linux-test` is a required check), and the host seams that surface
 exposed are fixed. Ships the structured goal ledger, the default-on

data/README.md

@@ -11,7 +11,7 @@ English | [Türkçe](README.tr.md)
 [![Protocol](https://img.shields.io/badge/protocol-AGENTS.md-blue.svg)](AGENTS.md)
 [![Commands Guide](https://img.shields.io/badge/docs-COMMANDS.md-yellow.svg)](COMMANDS.md)
 [![Config Guide](https://img.shields.io/badge/docs-CONFIG.md-green.svg)](CONFIG.md)
-[![Test Suite](https://img.shields.io/badge/tests-3202%20runs%20%7C%20100%25%20passed-brightgreen.svg)]()
+[![Test Suite](https://img.shields.io/badge/tests-3403%20runs%20%7C%20100%25%20passed-brightgreen.svg)]()
 
 ---
 
@@ -31,6 +31,12 @@ Requires **Ruby 3.4+**:
 gem install rubik
 ```
 
+The installer puts the `rubik` launcher into RubyGems' bin directory (already on your `PATH`), so you can start it from any project directory:
+
+```bash
+rubik
+```
+
 or with Bundler:
 
 ```ruby
@@ -73,6 +79,9 @@ ln -sf $(pwd)/bin/rubik ~/.local/bin/rubik
 rubik
 ```
 
+> [!NOTE]
+> **The gem and a clone can coexist.** On POSIX the symlink always runs your clone: `bin/rubik` resolves `lib/` from its own real path, so a `git pull` is live on the very next launch — even while the `rubik` gem stays installed. The gem-installed `rubik` keeps serving the last released version until you run `gem update rubik`. On Windows, whichever `bin` folder comes first in `PATH` wins — `where.exe rubik` shows the winner.
+
 #### 🪟 Windows (PowerShell / Command Prompt)
 
 Rubik ships with built-in `.cmd`, `.bat`, and `.ps1` wrappers for Windows:
@@ -105,6 +114,12 @@ rubik > !provider add deepseek openai_compatible https://api.deepseek.com/v1/cha
 rubik > !model deepseek/deepseek-coder
 ```
 
+Anthropic talks over its **native Messages API** (not an OpenAI shim): the `anthropic` provider is registered out of the box — set `ANTHROPIC_API_KEY` and pick a model:
+
+```bash
+rubik > !model anthropic/claude-sonnet-5-5
+```
+
 ### First Session Example
 
 ```text

data/lib/rubik/llm/anthropic.rb

@@ -9,7 +9,32 @@ module Rubik
     class AnthropicProvider < BaseProvider
       attr_reader :name, :model, :formatter, :headers, :api_key, :api_key_env
 
-      def initialize(name: nil, model: "claude-3-7-sonnet-20250219", formatter: AnthropicFormatter.new, headers: {},
+      # Extended-thinking support by model line (Anthropic docs, 2026-10):
+      #   :adaptive — 4.6+ and the 5.x/Fable lines: `thinking: {type: "adaptive"}`
+      #     with an `output_config` effort; the legacy budget_tokens form is
+      #     REJECTED with a 400 from 4.7 onward.
+      #   :legacy   — claude-3-7-sonnet through the 4.5 line: the manual
+      #     `thinking: {type: "enabled", budget_tokens: N}` form is the only
+      #     accepted mode.
+      #   nil       — 3.5-and-earlier lines accept no thinking at all, and
+      #     unrecognized names (custom aliases/proxies) get no auto thinking.
+      def self.thinking_mode_for(model_name)
+        s = model_name.to_s
+        return :legacy if s.include?("claude-3-7-sonnet")
+        return nil if s.match?(/\Aclaude-[23]/) # number-first 2.x/3.x lines (3-7 handled above)
+
+        # Single-digit captures: Anthropic versions are one digit per segment,
+        # so a snapshot date suffix (claude-sonnet-4-20250514) can never be
+        # swallowed as the minor version.
+        version = s.match(/\Aclaude-(?:sonnet|opus|haiku|fable)-(\d)(?:-(\d))?/)
+        return nil unless version
+
+        major = version[1].to_i
+        minor = version[2].to_i
+        major > 4 || (major == 4 && minor >= 6) ? :adaptive : :legacy
+      end
+
+      def initialize(name: nil, model: "claude-sonnet-5-5", formatter: AnthropicFormatter.new, headers: {},
                      api_key: nil, api_key_env: nil)
         super()
         @name = name.to_s.downcase
@@ -170,14 +195,25 @@ module Rubik
         thinking_opt = opts[:thinking]
         thinking_disabled = [false, :disabled].include?(thinking_opt)
         ratio = (opts[:thinking_budget_ratio] || 0.5).to_f
+        # Thinking is on for every model line that supports it unless
+        # explicitly disabled; thinking_budget_ratio only shapes the legacy
+        # budget form — adaptive models reason as they see fit.
+        mode = self.class.thinking_mode_for(target_model)
 
         if thinking_opt.is_a?(Hash)
           payload[:thinking] = thinking_opt
-        elsif !thinking_disabled && (thinking_opt == true || target_model.to_s.include?("claude-3-7-sonnet"))
-          if max_tokens > 2048
-            budget = [(max_tokens * ratio).to_i, 1024].max
-            budget = [budget, max_tokens - 1024].min
-            payload[:thinking] = { type: "enabled", budget_tokens: budget } if budget >= 1024
+        elsif !thinking_disabled && (thinking_opt == true || mode)
+          if mode == :legacy
+            if max_tokens > 2048
+              budget = [(max_tokens * ratio).to_i, 1024].max
+              budget = [budget, max_tokens - 1024].min
+              payload[:thinking] = { type: "enabled", budget_tokens: budget } if budget >= 1024
+            end
+          else
+            # Adaptive models reject the legacy form outright, and for
+            # unrecognized names adaptive is the modern-generation default.
+            payload[:thinking] = { type: "adaptive" }
+            payload[:output_config] = { effort: "high" }
           end
         end
 

data/lib/rubik/llm/registry.rb

@@ -38,7 +38,7 @@ module Rubik
         @providers = {
           "ollama" => OllamaProvider.new(model: "qwen2.5-coder:7b", headers: global_headers),
           "openai" => OpenAIProvider.new(model: "gpt-4o", headers: global_headers),
-          "anthropic" => AnthropicProvider.new(model: "claude-3-7-sonnet-20250219", headers: global_headers)
+          "anthropic" => AnthropicProvider.new(model: "claude-sonnet-5-5", headers: global_headers)
         }
         @models_catalog = {}
         load_from_config(config) if config
@@ -82,7 +82,7 @@ module Rubik
         end
         if @providers["anthropic"].instance_of?(AnthropicProvider)
           @providers["anthropic"] = AnthropicProvider.new(
-            model: @providers["anthropic"]&.model || "claude-3-7-sonnet-20250219",
+            model: @providers["anthropic"]&.model || "claude-sonnet-5-5",
             headers: global_headers
           )
         end
@@ -132,7 +132,7 @@ module Rubik
                             when "anthropic"
                               AnthropicProvider.new(
                                 name: p_name,
-                                model: default_model || "claude-3-7-sonnet-20250219",
+                                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.
@@ -257,7 +257,7 @@ module Rubik
         when "anthropic"
           anthropic_headers = (custom.respond_to?(:headers) ? custom.headers : nil) || global_headers
           AnthropicProvider.new(
-            model: model_name || "claude-3-7-sonnet-20250219",
+            model: model_name || "claude-sonnet-5-5",
             headers: anthropic_headers,
             api_key: custom.respond_to?(:api_key) ? custom.api_key : nil,
             api_key_env: custom.respond_to?(:api_key_env) ? custom.api_key_env : nil

data/lib/rubik/repl/commands/agent_execution.rb

@@ -127,6 +127,16 @@ module Rubik
                 # Adım sayacı rubik://goal/state'e aksın: olaylar bir adım
                 # içinde tekrarlanabilir, GoalState monotoniktir (zararsız).
                 goal_state.update_steps(step_info[:step], step_info[:max_steps]) if step_info[:step].is_a?(Integer)
+                # Session teşhis edilebilirliği (field incident 2026-10-12):
+                # saatler süren !goal koşuları session dosyasına tek satır
+                # düşürüyordu — free-text turn simetrisinde tool adımları
+                # kayıtçıya akar; render ve LLM geçmişi değişmez.
+                case step_info[:type]&.to_sym
+                when :tool_call
+                  ctx.recorder&.record_tool_call(step_info[:tool], step_info[:args], call_id: step_info[:call_id])
+                when :tool_result
+                  ctx.recorder&.record_tool_result(step_info[:tool], step_info[:output], status: step_info[:status] || :ok, call_id: step_info[:call_id])
+                end
                 ctx.render_step_event(step_info)
               }
             )
@@ -143,8 +153,28 @@ module Rubik
             end
 
             # Pruner apply seam: hedef döngüsü de aynı sınırda tohumlanır —
-            # aşamalı plan varsa goal promptundan ÖNCE uygulanır.
+            # aşamalı budama planı varsa goal promptundan ÖNCE uygulanır.
             ctx.apply_staged_prune_plan!
+
+            # Tek hata kanalı (field incident 2026-10-12): eskiden yalnızca
+            # normal :error dönüşü başarısızlık eşlemesini yapıyordu; loop'tan
+            # kaçan bir ClientError (sağlayıcı read timeout) goal'u kayıtsız
+            # 'running' bırakıyor, ledger terminal görmiyor ve session
+            # dosyası sessiz kalıyordu. Rescue dalları da aynı kapanış
+            # sırasını buradan çalıştırır. Kayıtçı '!goal ...' user_turn'unu
+            # komut girişinde çoktan yazdı — assistant_response olmadan
+            # session restore EŞLEŞMEMİŞ bir 'Goal: ...' turu hidrate ederdi.
+            # Adım sayısı: loop'un truncation hatası :steps'siz döner —
+            # GoalState monotonik sayacı otoriter yedek.
+            fail_goal = lambda do |reason, tokens: nil, steps: nil|
+              sanitized = Rubik::Platform.safe_utf8(reason.to_s)
+              steps_used = steps || goal_state.step_count
+              goal_state.fail!(sanitized, tokens: tokens)
+              finalize_ledger.call(:failed)
+              ctx.out.puts "\n❌ Goal could not be completed: #{sanitized}"
+              record_goal_pair.call("[Goal attempt ended after #{steps_used} steps: #{sanitized}]", tokens: tokens)
+            end
+
             ctx.active_loop = orchestrator
             begin
               res = orchestrator.run(goal_text, goal_mode: true, conversation_history: ctx.conversation_history)
@@ -170,6 +200,16 @@ module Rubik
               finalize_ledger.call(:stopped)
               record_goal_pair.call("[Goal attempt interrupted after #{goal_state.step_count} steps]")
               raise
+            rescue Rubik::LLM::ClientError => e
+              # execute_free_text simetrisi: sağlayıcı hatası (read timeout,
+              # HTTP 4xx) kaçarsa da goal terminal görür. Yeniden yükseltmez —
+              # spinner temizliği dispatch katmanına (execute_command) aittir.
+              # next: rescue sonrası akış res'siz `if res[:ok]`'a düşmesin.
+              fail_goal.call(e.message)
+              next
+            rescue StandardError => e
+              fail_goal.call("#{e.class}: #{e.message}")
+              next
             ensure
               ctx.active_loop = nil
             end
@@ -197,17 +237,10 @@ module Rubik
                 ctx.out.puts "\nTip: Use `!diff` to review changes and `!apply` to commit to disk." if ctx.buffer_manager.dirty?
               end
             else
-              # Başarısızlık eşlemesi: kayıtçı '!goal ...' user_turn'unu komut
-              # girişinde çoktan yazdı — assistant_response olmadan session
-              # restore EŞLEŞMEMİŞ bir 'Goal: ...' turu hidrate ederdi.
-              # Adım sayısı: loop'un truncation hatası :steps'siz döner —
-              # GoalState monotonik sayacı otoriter yedek.
-              sanitized = Rubik::Platform.safe_utf8(res[:error].to_s)
-              steps_used = res[:steps] || goal_state.step_count
-              goal_state.fail!(sanitized, tokens: res[:tokens])
-              finalize_ledger.call(:failed)
-              ctx.out.puts "\n❌ Goal could not be completed: #{sanitized}"
-              record_goal_pair.call("[Goal attempt ended after #{steps_used} steps: #{sanitized}]", tokens: res[:tokens])
+              # Başarısızlık eşlemesi yukarıdaki tek hata kanalından akar:
+              # GoalState → ledger finalize → kayıtçı çifti, istisna yoluyla
+              # aynı sırayla.
+              fail_goal.call(res[:error], tokens: res[:tokens], steps: res[:steps])
             end
           end
         end

data/lib/rubik/repl/input_execution.rb

@@ -56,6 +56,11 @@ module Rubik
             rescue Interrupt
               Rubik::REPL::InterruptHandler.restore_console_after_interrupt
               @output.puts "\n⚠️ [Rubik] Komut kullanıcı tarafından iptal edildi (^C)."
+            ensure
+              # !goal dahil lifecycle komutları tracked dal ile aynı spinner
+              # garantisini taşır (field incident 2026-10-12: !goal'ten kaçan
+              # ClientError'da öksüz spinner terminali kilitli gösterdi).
+              kill_command_spinner!
             end
           else
             captured = StringIO.new
@@ -70,7 +75,7 @@ module Rubik
               @output.puts "\n⚠️ [Rubik] Komut kullanıcı tarafından iptal edildi (^C)."
             ensure
               # A command (!plan/!goal) may leave a live spinner if it died mid-wait.
-              @ui_renderer&.spinner&.kill
+              kill_command_spinner!
             end
             output_text = captured.string.strip
             if !cmd_interrupted && !output_text.empty?
@@ -297,11 +302,7 @@ module Rubik
         rescue StandardError => e
           warn "[rubik] markdown tail flush failed: #{e.class}: #{e.message}"
         end
-        begin
-          renderer&.spinner&.kill
-        rescue StandardError => e
-          warn "[rubik] spinner cleanup failed: #{e.class}: #{e.message}"
-        end
+        kill_spinner!(renderer&.spinner)
         flush_subagent_notices! if respond_to?(:flush_subagent_notices!)
         # Session review B3: notices stranded in the ended loop's inbox never
         # reached the model channel and owed no wake — an idle maestro learned
@@ -318,6 +319,21 @@ module Rubik
         end
         reap_dead_kernel_units! if respond_to?(:reap_dead_kernel_units!)
       end
+
+      # Shared spinner teardown. Cleanup must never mask the in-flight
+      # exception (AGENTS.md §5): a spinner whose tick thread died holding
+      # the mutex raises ThreadError from synchronize — report it to stderr
+      # and continue so the real failure surfaces.
+      def kill_spinner!(spinner)
+        spinner&.kill
+      rescue StandardError => e
+        warn "[rubik] spinner cleanup failed: #{e.class}: #{e.message}"
+      end
+
+      # Command-dispatch spinner cleanup (both branches).
+      def kill_command_spinner!
+        kill_spinner!(@ui_renderer&.spinner)
+      end
     end
   end
 end

data/lib/rubik/security/redactor.rb

@@ -20,6 +20,11 @@ module Rubik
       ASSIGNMENT_KEY_REGEX = /\b(password|passwd|api_key|secret)(\s*[:=]\s*)(['"][^'"]*['"]|[^\s,;'"]+)/i
       ASSIGNMENT_TOKEN_REGEX = /\b(token)(\s*[:=]\s*)(['"][^'"]*['"]|[^\s,;'"]+)/i
 
+      # PERF: Pre-compiled constants to avoid re-allocation inside hot loops
+      URL_PATTERN = %r{(https?://[^:]+:)([^@]+)@}
+      URL_MASK = "\\1#{MASK_STRING}@".freeze
+      QUICK_CHECK_REGEX = %r{sk-|AKIA|ghp_|github_pat_|AIza|bearer|PRIVATE KEY|://[^:]+:|password|passwd|api_key|secret|token}i
+
       # Anahtar-maskeleme desenleri (Session::Recorder#mask_payload ile aynı
       # aile): sır görünümlü anahtarların değerleri desen eşleşmese bile
       # maskelenir; sayaç anahtarları (tokens, max_tokens) istisnadır.
@@ -33,10 +38,17 @@ module Rubik
         # scrub: redact ham geçmişe (tool çıktısı, prompt) dokunur — geçersiz
         # UTF-8 gsub!'ı ArgumentError ile düşürür; total olmak maskenin
         # kendisi bir arıza kaynağı olmasın demektir.
-        result = text.dup.scrub
+        result = text.valid_encoding? ? text.dup : text.scrub
+
+        # PERF: kısa devre — sır tetikleyicisi yoksa 11 gsub turu atlanır.
+        # Tetik testi scrub'lanmış sonuç üstünde yapılır: match? ham geçersiz
+        # UTF-8'de ArgumentError düşürür; scrub sonrası metin hep geçerlidir
+        # ve desenler zaten bu metne uygulanıyordu, dolayısıyla eşdeğerdir.
+        return result unless result.match?(QUICK_CHECK_REGEX)
+
         PATTERNS.each do |pattern|
-          if pattern == %r{(https?://[^:]+:)([^@]+)@}
-            result.gsub!(pattern, "\\1#{MASK_STRING}@")
+          if pattern == URL_PATTERN
+            result.gsub!(pattern, URL_MASK)
           else
             result.gsub!(pattern, MASK_STRING)
           end

data/lib/rubik/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubik
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubik
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Özgür Ulukır