openclacky 1.5.7 → 1.5.9

data/lib/clacky/session_manager.rb

@@ -335,6 +335,13 @@ module Clacky
     # sessions are never deleted and do not count toward the cap.
     # Returns count of soft-deleted sessions.
     def cleanup_by_count(keep:, grouped_keep: 200)
+      # Fast path: if total session files can't exceed any single group's cap,
+      # skip the expensive all_sessions() full-scan (read + JSON.parse every file).
+      # min() is correct because groups are mutually exclusive — any single
+      # group's count ≤ non_pinned ≤ file_count ≤ min(keep, grouped_keep).
+      file_count = Dir.glob(File.join(@sessions_dir, "*.json")).size
+      return 0 if file_count <= [keep, grouped_keep].min
+
       non_pinned = all_sessions.reject { |s| s[:pinned] }
 
       groups = non_pinned.group_by do |s|

data/lib/clacky/skill_loader.rb

@@ -485,6 +485,10 @@ module Clacky
 
       result.skills.each do |unit|
         next if unit.spec["protected"] || unit.spec["encrypted"]
+        # Builtin extension skills are already loaded as :default by
+        # load_default_skills; skipping them here keeps their source stable
+        # instead of being re-registered (and reclassified) as :extension.
+        next if unit.layer == :builtin
 
         skill_dir_abs = unit.spec["skill_dir_abs"]
         next unless File.directory?(skill_dir_abs) && File.file?(File.join(skill_dir_abs, "SKILL.md"))

data/lib/clacky/tools/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../utils/environment_detector"
+
 module Clacky
   module Tools
     class Base
@@ -29,12 +31,20 @@ module Clacky
       end
 
       # Expand ~ to home directory only if path starts with ~
-      # Relative paths are resolved against working_dir if provided
+      # Relative paths are resolved against working_dir if provided.
+      # On WSL, Windows-style paths (C:\..., C:/..., /C:/...) are translated to
+      # their /mnt/<drive>/... equivalents so that paths copied from Windows
+      # (clipboard, error messages, file dialogs) work unchanged.
       # @param path [String, nil] The path to expand
       # @param working_dir [String, nil] The working directory to resolve relative paths against
       # @return [String, nil] The expanded path, or original if no ~ present
       private def expand_path(path, working_dir: nil)
         return path if path.nil? || path.strip.empty?
+
+        # WSL: normalize Windows drive paths BEFORE anything else, otherwise
+        # the leading "C:" makes File.expand_path treat them as relative.
+        path = Clacky::Utils::EnvironmentDetector.win_to_linux_path(path)
+
         return File.expand_path(path) if path.start_with?("~")
         return File.expand_path(path, working_dir) if working_dir && !path.start_with?("/")
         # Always resolve relative paths to absolute (even without working_dir), so callers

data/lib/clacky/tools/edit.rb

@@ -49,6 +49,14 @@ module Clacky
           # and cause JSON.generate to fail during replay.
           content = safe_utf8(File.read(path))
 
+          # Detect the file's dominant line-ending style BEFORE any
+          # modification. Windows-created files (and /mnt/c on WSL) use
+          # CRLF; AI-supplied old_string/new_string always use LF. Without
+          # preservation, the replaced fragment introduces LF into a CRLF
+          # file, creating mixed line endings that confuse Git diff and
+          # Windows IDEs.
+          preserve_crlf = content.include?("\r\n")
+
           # Find matching string using layered strategy (shared with preview)
           match_result = Utils::StringMatcher.find_match(content, old_string)
 
@@ -82,6 +90,11 @@ module Clacky
                       content.sub(actual_old_string) { new_string }
                     end
 
+          # Preserve the original line-ending style: if the file was CRLF,
+          # re-normalize the entire content to CRLF so the newly inserted
+          # LF fragments (from new_string) match the rest of the file.
+          content = normalize_line_endings(content, :crlf) if preserve_crlf
+
           File.write(path, content)
 
           {
@@ -143,6 +156,21 @@ module Clacky
         "Modified #{replacements} occurrence#{replacements > 1 ? "s" : ""}"
       end
 
+      # Normalize all line endings in `content` to the given style.
+      # Works by first collapsing everything to LF, then expanding to the
+      # target — this avoids double-converting existing CRLF into CRCRLF.
+      # @param content [String]
+      # @param style [Symbol] :crlf or :lf
+      # @return [String]
+      private def normalize_line_endings(content, style)
+        case style
+        when :crlf
+          content.gsub(/\r\n/, "\n").gsub(/\r/, "\n").gsub(/\n/, "\r\n")
+        else
+          content.gsub(/\r\n/, "\n").gsub(/\r/, "\n")
+        end
+      end
+
       # Scrub invalid UTF-8 byte sequences (see file_reader.rb for rationale).
       private def safe_utf8(str)
         return str if str.nil?

data/lib/clacky/tools/terminal.rb

@@ -223,6 +223,11 @@ module Clacky
         timeout = (timeout || DEFAULT_TIMEOUT).to_f
         idle_ms = (idle_ms || DEFAULT_IDLE_MS).to_i
         cwd ||= working_dir
+        # Normalize cwd the same way file tools do: on WSL translate Windows
+        # drive paths (C:\..., C:/...) to /mnt, expand ~ and relative paths.
+        # Without this, a Windows-style cwd fails the Dir.exist? check below
+        # and the agent gets a misleading "cwd does not exist".
+        cwd = expand_path(cwd) if cwd
 
         # Kill
         if kill

data/lib/clacky/tools/trash_manager.rb

@@ -93,7 +93,7 @@ module Clacky
 
       def restore_file(trash_dir, file_path, project_root)
         deleted_files = get_deleted_files(trash_dir, project_root)
-        expanded_path = File.expand_path(file_path, project_root)
+        expanded_path = expand_path(file_path, working_dir: project_root)
 
         target_file = deleted_files.find { |f| f[:original_path] == expanded_path }
 

data/lib/clacky/ui2/components/inline_input.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "tty-screen"
 require_relative "../line_editor"
 
 module Clacky

data/lib/clacky/ui2/components/input_area.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "tty-screen"
 require "tempfile"
 require_relative "../theme_manager"
 require_relative "../line_editor"

data/lib/clacky/ui2/components/modal_component.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'io/console'
-require 'tty-prompt'
 require_relative 'base_component'
 
 module Clacky

data/lib/clacky/ui2/components/todo_area.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "tty-screen"
 
 module Clacky
   module UI2

data/lib/clacky/ui2/line_editor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "tty-screen"
 
 module Clacky
   module UI2

data/lib/clacky/ui2/markdown_renderer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "tty-markdown"
+require "tty-screen"
 require_relative "theme_manager"
 
 module Clacky
@@ -14,6 +14,10 @@ module Clacky
         def render(content)
           return content if content.nil? || content.empty?
 
+          # tty-markdown pulls in rouge + kramdown (~0.4s). Server mode renders
+          # markdown in the browser, so only pay that cost on a real terminal render.
+          require "tty-markdown" unless defined?(TTY::Markdown)
+
           # Get current theme colors
           theme = ThemeManager.current_theme
 

data/lib/clacky/ui2/ui_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pastel"
 require_relative "layout_manager"
 require_relative "view_renderer"
 require_relative "progress_handle"

data/lib/clacky/utils/model_pricing.rb

@@ -159,37 +159,45 @@ module Clacky
       #   - "cache miss input" = regular prompt_tokens rate
       #   - "cache hit input"  = cache_read rate (DeepSeek has no separate cache-write charge)
       #   - No tiered pricing (single rate regardless of context length)
-      # Cache-hit prices are 1/10 of launch (global, permanent since 2026-04-26).
-      # v4-pro is on a 75% off promo through 2026-05-31 23:59 CST; the same
-      # numbers become the permanent price after that date (= original × 1/4),
-      # so we bill at the discounted rates both before and after the cutover.
+      # Effective 2026-08-16 16:00 UTC DeepSeek switched to peak/off-peak billing
+      # (off-peak = half of peak; peak = 01:00-04:00 & 06:00-10:00 UTC).
+      # Each entry carries legacy/peak/off_peak tiers; calculate_cost resolves
+      # the active tier from the request time.
       "deepseek-v4-flash" => {
-        input: {
-          default: 0.14,                  # $0.14/MTok cache miss
-          over_200k: 0.14                 # no tiered pricing
-        },
-        output: {
-          default: 0.28,                  # $0.28/MTok
-          over_200k: 0.28
-        },
-        cache: {
-          write: 0.14,                    # DeepSeek doesn't charge extra for writes; bill at miss rate
-          read: 0.0028                    # $0.0028/MTok cache hit
+        deepseek: true,
+        legacy: {
+          input:  { default: 0.14,   over_200k: 0.14 },   # $0.14/MTok  (pre-cutover flat)
+          output: { default: 0.28,   over_200k: 0.28 },   # $0.28/MTok
+          cache:  { write: 0.14,     read: 0.0028 }       # $0.0028/MTok cache hit
+        },
+        peak: {
+          input:  { default: 0.44,   over_200k: 0.44 },   # $0.44/MTok  cache miss (peak)
+          output: { default: 1.32,   over_200k: 1.32 },   # $1.32/MTok
+          cache:  { write: 0.44,     read: 0.014 }        # $0.014/MTok cache hit
+        },
+        off_peak: {
+          input:  { default: 0.22,   over_200k: 0.22 },   # $0.22/MTok  (half of peak)
+          output: { default: 0.66,   over_200k: 0.66 },   # $0.66/MTok
+          cache:  { write: 0.22,     read: 0.007 }        # $0.007/MTok cache hit
         }
       },
 
       "deepseek-v4-pro" => {
-        input: {
-          default: 0.435,                 # $0.435/MTok cache miss (75% off; permanent after 5/31)
-          over_200k: 0.435
-        },
-        output: {
-          default: 0.87,                  # $0.87/MTok (75% off; permanent after 5/31)
-          over_200k: 0.87
-        },
-        cache: {
-          write: 0.435,                   # no separate write charge; bill at miss rate
-          read: 0.003625                  # $0.003625/MTok cache hit (1/10 × 75% off)
+        deepseek: true,
+        legacy: {
+          input:  { default: 0.435,  over_200k: 0.435 },  # $0.435/MTok  (pre-cutover flat)
+          output: { default: 0.87,   over_200k: 0.87 },   # $0.87/MTok
+          cache:  { write: 0.435,    read: 0.003625 }     # $0.003625/MTok cache hit
+        },
+        peak: {
+          input:  { default: 1.32,   over_200k: 1.32 },   # $1.32/MTok  cache miss (peak)
+          output: { default: 3.96,   over_200k: 3.96 },   # $3.96/MTok
+          cache:  { write: 1.32,     read: 0.044 }        # $0.044/MTok cache hit
+        },
+        off_peak: {
+          input:  { default: 0.66,   over_200k: 0.66 },   # $0.66/MTok  (half of peak)
+          output: { default: 1.98,   over_200k: 1.98 },   # $1.98/MTok
+          cache:  { write: 0.66,     read: 0.022 }        # $0.022/MTok cache hit
         }
       },
 
@@ -687,6 +695,10 @@ module Clacky
     # Costs for prompts between 200K–272K will be slightly over-estimated.
     TIERED_PRICING_THRESHOLD = 200_000
 
+    # DeepSeek switched from flat legacy rates to peak/off-peak billing at
+    # 2026-08-17 00:00 Beijing time (= 2026-08-16 16:00 UTC).
+    DEEPSEEK_PEAK_PRICING_START = Time.utc(2026, 8, 16, 16, 0, 0).freeze
+
     class << self
       # Calculate cost for the given model and usage
       #
@@ -696,10 +708,12 @@ module Clacky
       #   - completion_tokens: number of output tokens
       #   - cache_creation_input_tokens: tokens written to cache (optional)
       #   - cache_read_input_tokens: tokens read from cache (optional)
+      # @param now [Time] Request time used to resolve peak/off-peak tiers
+      #   (defaults to the current time)
       # @return [Hash] Hash containing:
       #   - cost: Cost in USD (Float) or nil if model pricing is unknown
       #   - source: Cost source (:price) or nil if unknown (Symbol or nil)
-      def calculate_cost(model:, usage:)
+      def calculate_cost(model:, usage:, now: Time.now)
         pricing_result = get_pricing_with_source(model)
         pricing = pricing_result[:pricing]
         source = pricing_result[:source]
@@ -708,6 +722,9 @@ module Clacky
         # Unknown models should display as N/A, never fall back to guesses.
         return { cost: nil, source: nil } unless pricing
 
+        # DeepSeek peak/off-peak pricing: resolve to the tier active at `now`.
+        pricing = resolve_deepseek_tier(pricing, now) if pricing[:deepseek]
+
         prompt_tokens = usage[:prompt_tokens] || 0
         completion_tokens = usage[:completion_tokens] || 0
         cache_write_tokens = usage[:cache_creation_input_tokens] || 0
@@ -960,6 +977,24 @@ module Clacky
 
         cache_cost
       end
+
+      # Resolve a DeepSeek pricing entry (which holds legacy/peak/off_peak
+      # tiers) to the single tier that applies at the given time.
+      def resolve_deepseek_tier(pricing, now)
+        if now < DEEPSEEK_PEAK_PRICING_START
+          pricing[:legacy]
+        elsif deepseek_peak_hour?(now)
+          pricing[:peak]
+        else
+          pricing[:off_peak]
+        end
+      end
+
+      # Peak hours: 01:00-04:00 and 06:00-10:00 UTC (all other hours off-peak).
+      def deepseek_peak_hour?(time)
+        hour = time.utc.hour
+        (hour >= 1 && hour < 4) || (hour >= 6 && hour < 10)
+      end
     end
   end
 end

data/lib/clacky/utils/string_matcher.rb

@@ -6,6 +6,22 @@ module Clacky
     # Used by the Edit tool and edit preview to apply a consistent
     # layered matching strategy: exact → trim → unescape → smart line match.
     module StringMatcher
+      # Visually-identical Unicode punctuation LLMs swap for ASCII when
+      # re-quoting file content (and vice versa). Mapping is 1:1 so character
+      # indices are preserved, letting normalized matches map back to the
+      # original string.
+      HOMOGLYPHS = {
+        "\u2013" => "-",  # – EN DASH
+        "\u2014" => "-",  # — EM DASH
+        "\u2212" => "-",  # − MINUS SIGN
+        "\u2018" => "'",  # ‘ LEFT SINGLE QUOTATION MARK
+        "\u2019" => "'",  # ’ RIGHT SINGLE QUOTATION MARK
+        "\u201C" => '"',  # “ LEFT DOUBLE QUOTATION MARK
+        "\u201D" => '"'   # ” RIGHT DOUBLE QUOTATION MARK
+      }.freeze
+
+      HOMOGLYPH_PATTERN = /[\u2013\u2014\u2212\u2018\u2019\u201C\u201D]/.freeze
+
       # Find a matching string in content using a layered strategy.
       #
       # Strategy (applied in order):
@@ -13,7 +29,7 @@ module Clacky
       #   2. Trimmed match (leading/trailing whitespace stripped)
       #   3. Unescaped match (over-escaped sequences normalised)
       #   4. Combined trim + unescape
-      #   5. Smart line-by-line match (tolerates indent differences)
+      #   5. Smart line-by-line match (tolerates indent & Unicode homoglyphs)
       #
       # @param content [String] File content to search in
       # @param old_string [String] String to locate
@@ -77,6 +93,14 @@ module Clacky
         ].uniq
       end
 
+      # Map visually-identical Unicode punctuation to ASCII equivalents.
+      def self.normalize_homoglyphs(str)
+        return str if str.nil? || str.empty?
+        return str unless HOMOGLYPH_PATTERN.match?(str)
+
+        str.each_char.map { |ch| HOMOGLYPHS.fetch(ch, ch) }.join
+      end
+
       # Convert over-escaped sequences back to their real characters.
       # This handles the common case where LLMs double-escape backslashes.
       #
@@ -150,7 +174,10 @@ module Clacky
           norm1 = line1.sub(/^\s+/, " ").chomp
           norm2 = line2.sub(/^\s+/, " ").chomp
 
-          norm1 == norm2 || norm1 == unescape_over_escaped(norm2)
+          norm1 == norm2 ||
+            norm1 == unescape_over_escaped(norm2) ||
+            normalize_homoglyphs(norm1) == normalize_homoglyphs(norm2) ||
+            normalize_homoglyphs(norm1) == normalize_homoglyphs(unescape_over_escaped(norm2))
         end
       end
     end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.5.7"
+  VERSION = "1.5.9"
 end