openclacky 0.6.2 → 0.6.4

data/lib/clacky/skill_loader.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "fileutils"
+require "clacky"
+
+module Clacky
+  # Loader and registry for skills.
+  # Discovers skills from multiple locations and provides lookup functionality.
+  class SkillLoader
+    # Skill discovery locations (in priority order: lower index = lower priority)
+    LOCATIONS = [
+      :default,            # gem's built-in default skills (lowest priority)
+      :global_claude,      # ~/.claude/skills/ (compatibility)
+      :global_clacky,      # ~/.clacky/skills/
+      :project_claude,     # .claude/skills/ (project-level compatibility)
+      :project_clacky      # .clacky/skills/ (highest priority)
+    ].freeze
+
+    # Initialize the skill loader and automatically load all skills
+    # @param working_dir [String] Current working directory for project-level discovery
+    def initialize(working_dir = nil)
+      @working_dir = working_dir || Dir.pwd
+      @skills = {}           # Map identifier -> Skill
+      @skills_by_command = {} # Map slash_command -> Skill
+      @errors = []           # Store loading errors
+      @loaded_from = {}      # Track which location each skill was loaded from
+      
+      # Automatically load all skills on initialization
+      load_all
+    end
+
+    # Load all skills from configured locations
+    # Clears previously loaded skills before loading to ensure idempotency
+    # @return [Array<Skill>] Loaded skills
+    def load_all
+      # Clear existing skills to ensure idempotent reloading
+      clear
+      
+      load_default_skills
+      load_global_claude_skills
+      load_global_clacky_skills
+      load_project_claude_skills
+      load_project_clacky_skills
+
+      all_skills
+    end
+
+    # Load skills from ~/.claude/skills/ (lowest priority, compatibility)
+    # @return [Array<Skill>]
+    def load_global_claude_skills
+      global_claude_dir = Pathname.new(ENV.fetch("HOME", "~")).join(".claude", "skills")
+      load_skills_from_directory(global_claude_dir, :global_claude)
+    end
+
+    # Load skills from ~/.clacky/skills/ (user global)
+    # @return [Array<Skill>]
+    def load_global_clacky_skills
+      global_clacky_dir = Pathname.new(ENV.fetch("HOME", "~")).join(".clacky", "skills")
+      load_skills_from_directory(global_clacky_dir, :global_clacky)
+    end
+
+    # Load skills from .claude/skills/ (project-level compatibility)
+    # @return [Array<Skill>]
+    def load_project_claude_skills
+      project_claude_dir = Pathname.new(@working_dir).join(".claude", "skills")
+      load_skills_from_directory(project_claude_dir, :project_claude)
+    end
+
+    # Load skills from .clacky/skills/ (project-level, highest priority)
+    # @return [Array<Skill>]
+    def load_project_clacky_skills
+      project_clacky_dir = Pathname.new(@working_dir).join(".clacky", "skills")
+      load_skills_from_directory(project_clacky_dir, :project_clacky)
+    end
+
+    # Load skills from nested .claude/skills/ directories (monorepo support)
+    # @return [Array<Skill>]
+    def load_nested_project_skills
+      working_path = Pathname.new(@working_dir)
+
+      # Find all nested .claude/skills/ directories
+      nested_dirs = []
+      begin
+        Dir.glob("**/.claude/skills/", base: @working_dir).each do |relative_path|
+          nested_dirs << working_path.join(relative_path)
+        end
+      rescue ArgumentError
+        # Skip if working_dir contains special characters
+      end
+
+      # Filter out the main project .claude/skills/ (already loaded)
+      main_project_skills = working_path.join(".claude", "skills").realpath
+
+      nested_dirs.each do |dir|
+        next if dir.realpath == main_project_skills
+
+        # Determine the source path for priority resolution
+        # Use the parent directory of .claude as the source
+        source_path = dir.parent
+
+        # Determine skill identifier based on relative path from working_dir
+        relative_to_working = dir.relative_path_from(working_path).to_s
+        skill_name = relative_to_working.gsub(".claude/skills/", "").gsub("/", "-")
+
+        load_single_skill(dir, source_path, skill_name)
+      end
+    end
+
+    # Get all loaded skills
+    # @return [Array<Skill>]
+    def all_skills
+      @skills.values
+    end
+
+    # Get a skill by its identifier
+    # @param identifier [String] Skill name or directory name
+    # @return [Skill, nil]
+    def [](identifier)
+      @skills[identifier]
+    end
+
+    # Find a skill by its slash command
+    # @param command [String] e.g., "/explain-code"
+    # @return [Skill, nil]
+    def find_by_command(command)
+      @skills_by_command[command]
+    end
+
+    # Get skills that can be invoked by user
+    # @return [Array<Skill>]
+    def user_invocable_skills
+      all_skills.select(&:user_invocable?)
+    end
+
+    # Get the count of loaded skills
+    # @return [Integer]
+    def count
+      @skills.size
+    end
+
+    # Get loading errors
+    # @return [Array<String>]
+    def errors
+      @errors.dup
+    end
+
+    # Get the source location for each loaded skill
+    # @return [Hash{String => Symbol}] Map of skill identifier to source location
+    def loaded_from
+      @loaded_from.dup
+    end
+
+    # Clear loaded skills and errors
+    def clear
+      @skills.clear
+      @skills_by_command.clear
+      @errors.clear
+    end
+
+    # Create a new skill directory and SKILL.md file
+    # @param name [String] Skill name (will be used for directory and slash command)
+    # @param content [String] Skill content (SKILL.md body)
+    # @param description [String] Skill description
+    # @param location [Symbol] Where to create: :global or :project
+    # @return [Skill] The created skill
+    def create_skill(name, content, description = nil, location: :global)
+      # Validate name
+      unless name.match?(/^[a-z0-9][a-z0-9-]*$/)
+        raise Clacky::AgentError,
+          "Invalid skill name '#{name}'. Use lowercase letters, numbers, and hyphens only."
+      end
+
+      # Determine directory path
+      skill_dir = case location
+      when :global
+        Pathname.new(ENV.fetch("HOME", "~")).join(".clacky", "skills", name)
+      when :project
+        Pathname.new(@working_dir).join(".clacky", "skills", name)
+      else
+        raise Clacky::AgentError, "Unknown skill location: #{location}"
+      end
+
+      # Create directory if it doesn't exist
+      FileUtils.mkdir_p(skill_dir)
+
+      # Build frontmatter
+      frontmatter = { "name" => name, "description" => description }
+
+      # Write SKILL.md
+      skill_content = build_skill_content(frontmatter, content)
+      skill_file = skill_dir.join("SKILL.md")
+      skill_file.write(skill_content)
+
+      # Load the newly created skill
+      source_type = case location
+      when :global then :global_clacky
+      when :project then :project_clacky
+      else :global_clacky
+      end
+      load_single_skill(skill_dir, skill_dir, name, source_type)
+    end
+
+    # Delete a skill
+    # @param name [String] Skill name
+    # @return [Boolean] True if deleted, false if not found
+    def delete_skill(name)
+      skill = @skills[name]
+      return false unless skill
+
+      # Remove from registry
+      @skills.delete(name)
+      @skills_by_command.delete(skill.slash_command)
+
+      # Delete directory
+      FileUtils.rm_rf(skill.directory)
+
+      true
+    end
+
+    private
+
+    def load_skills_from_directory(dir, source_type)
+      return [] unless dir.exist?
+
+      skills = []
+      dir.children.select(&:directory?).each do |skill_dir|
+        source_path = case source_type
+        when :global_claude
+          Pathname.new(ENV.fetch("HOME", "~")).join(".claude")
+        when :global_clacky
+          Pathname.new(ENV.fetch("HOME", "~")).join(".clacky")
+        when :project_claude, :project_clacky
+          Pathname.new(@working_dir)
+        else
+          skill_dir
+        end
+
+        skill_name = skill_dir.basename.to_s
+        skill = load_single_skill(skill_dir, source_path, skill_name, source_type)
+        skills << skill if skill
+      end
+      skills
+    end
+
+    def load_single_skill(skill_dir, source_path, skill_name, source_type)
+      skill = Skill.new(skill_dir, source_path: source_path)
+
+      # Check for duplicate names
+      existing = @skills[skill.identifier]
+      if existing
+        # Skip duplicate (lower priority)
+        existing_source = @loaded_from[skill.identifier]
+        priority_order = [:global_claude, :global_clacky, :project_claude, :project_clacky]
+
+        if priority_order.index(source_type) > priority_order.index(existing_source)
+          # Replace with higher priority skill
+          @skills.delete(existing.identifier)
+          @skills_by_command.delete(existing.slash_command)
+          @loaded_from.delete(existing.identifier)
+        else
+          @errors << "Skipping duplicate skill '#{skill.identifier}' at #{skill_dir}"
+          return nil
+        end
+      end
+
+      # Register skill
+      @skills[skill.identifier] = skill
+      @skills_by_command[skill.slash_command] = skill
+      @loaded_from[skill.identifier] = source_type
+
+      skill
+    rescue Clacky::AgentError => e
+      @errors << "Error loading skill '#{skill_name}' from #{skill_dir}: #{e.message}"
+      nil
+    rescue StandardError => e
+      @errors << "Unexpected error loading skill '#{skill_name}' from #{skill_dir}: #{e.message}"
+      nil
+    end
+
+    def build_skill_content(frontmatter, content)
+      yaml = frontmatter
+        .reject { |_, v| v.nil? || v.to_s.empty? }
+        .to_yaml(line_width: 80)
+
+      "---\n#{yaml}---\n\n#{content}"
+    end
+
+    # Load default skills from gem's default_skills directory
+    private def load_default_skills
+      # Get the gem's lib directory
+      gem_lib_dir = File.expand_path("../", __dir__)
+      default_skills_dir = File.join(gem_lib_dir, "clacky", "default_skills")
+      
+      return unless Dir.exist?(default_skills_dir)
+      
+      # Load each skill directory
+      Dir.glob(File.join(default_skills_dir, "*/SKILL.md")).each do |skill_file|
+        skill_dir = File.dirname(skill_file)
+        skill_name = File.basename(skill_dir)
+        
+        begin
+          skill = Skill.new(Pathname.new(skill_dir))
+          
+          # Check for duplicates (higher priority skills override)
+          if @skills.key?(skill.identifier)
+            next  # Skip if already loaded from higher priority location
+          end
+          
+          # Register skill
+          @skills[skill.identifier] = skill
+          @skills_by_command[skill.slash_command] = skill
+          @loaded_from[skill.identifier] = :default
+        rescue StandardError => e
+          @errors << "Failed to load default skill #{skill_name}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/tools/edit.rb

@@ -46,14 +46,23 @@ module Clacky
           content = File.read(path)
           original_content = content.dup
 
-          # Check if old_string exists
-          unless content.include?(old_string)
-            return { error: "String to replace not found in file" }
+          # Try exact match first
+          if content.include?(old_string)
+            actual_old_string = old_string
+            occurrences = content.scan(old_string).length
+          else
+            # Try smart whitespace normalization
+            match_result = try_smart_match(content, old_string)
+            
+            if match_result
+              actual_old_string = match_result[:matched_string]
+              occurrences = match_result[:occurrences]
+            else
+              # Provide helpful error with context
+              return build_helpful_error(content, old_string, path)
+            end
           end
 
-          # Count occurrences
-          occurrences = content.scan(old_string).length
-
           # If not replace_all and multiple occurrences, warn about ambiguity
           if !replace_all && occurrences > 1
             return {
@@ -64,9 +73,9 @@ module Clacky
 
           # Perform replacement
           if replace_all
-            content = content.gsub(old_string, new_string)
+            content = content.gsub(actual_old_string, new_string)
           else
-            content = content.sub(old_string, new_string)
+            content = content.sub(actual_old_string, new_string)
           end
 
           # Write modified content
@@ -84,6 +93,100 @@ module Clacky
         end
       end
 
+      private def try_smart_match(content, old_string)
+        # Normalize whitespace: convert all leading whitespace to single space for comparison
+        normalized_old = normalize_leading_whitespace(old_string)
+        
+        # Find all potential matches in content with normalized whitespace
+        matches = []
+        content_lines = content.lines
+        old_lines = old_string.lines
+        
+        return nil if old_lines.empty?
+        
+        # Scan through content to find matches
+        (0..content_lines.length - old_lines.length).each do |start_idx|
+          slice = content_lines[start_idx, old_lines.length]
+          next unless slice
+          
+          # Check if this slice matches when normalized
+          if lines_match_normalized?(slice, old_lines)
+            matched_string = slice.join
+            matches << { start: start_idx, matched_string: matched_string }
+          end
+        end
+        
+        return nil if matches.empty?
+        
+        # Return the first match and count total occurrences
+        {
+          matched_string: matches.first[:matched_string],
+          occurrences: matches.length
+        }
+      end
+
+      private def normalize_leading_whitespace(text)
+        # Normalize each line's leading whitespace
+        text.lines.map { |line| line.sub(/^\s+/, ' ') }.join
+      end
+
+      private def lines_match_normalized?(lines1, lines2)
+        return false unless lines1.length == lines2.length
+        
+        lines1.zip(lines2).all? do |line1, line2|
+          # Normalize leading whitespace and compare
+          norm1 = line1.sub(/^\s+/, ' ')
+          norm2 = line2.sub(/^\s+/, ' ')
+          norm1 == norm2
+        end
+      end
+
+      private def build_helpful_error(content, old_string, path)
+        # Find similar content to help debug
+        old_lines = old_string.lines
+        first_line_pattern = old_lines.first&.strip
+        
+        if first_line_pattern && !first_line_pattern.empty?
+          # Find lines that match the first line (ignoring whitespace)
+          content_lines = content.lines
+          similar_locations = []
+          
+          content_lines.each_with_index do |line, idx|
+            if line.strip == first_line_pattern
+              # Show context: 2 lines before and after
+              start_idx = [0, idx - 2].max
+              end_idx = [content_lines.length - 1, idx + old_lines.length + 2].min
+              context = content_lines[start_idx..end_idx].join
+              
+              similar_locations << {
+                line_number: idx + 1,
+                context: context
+              }
+            end
+          end
+          
+          if similar_locations.any?
+            context_preview = similar_locations.first[:context]
+            # Escape newlines for better display
+            context_display = context_preview.lines.first(5).map { |l| "  #{l}" }.join
+            
+            return {
+              error: "String to replace not found in file. The first line of old_string exists at line #{similar_locations.first[:line_number]}, " \
+                     "but the full multi-line string doesn't match. This is often caused by whitespace differences (tabs vs spaces). " \
+                     "\n\nContext around line #{similar_locations.first[:line_number]}:\n#{context_display}\n\n" \
+                     "TIP: Make sure to copy the exact whitespace characters from the file. Use file_reader to see the actual content."
+            }
+          end
+        end
+        
+        # Generic error if no similar content found
+        {
+          error: "String to replace not found in file '#{File.basename(path)}'. " \
+                 "Make sure old_string matches exactly (including all whitespace). " \
+                 "TIP: Use file_reader to view the exact content first, then copy the exact string including all spaces and tabs."
+        }
+      end
+
       def format_call(args)
         path = args[:file_path] || args['file_path'] || args[:path] || args['path']
         "Edit(#{Utils::PathHelper.safe_basename(path)})"

data/lib/clacky/tools/file_reader.rb

@@ -18,8 +18,20 @@ module Clacky
           },
           max_lines: {
             type: "integer",
-            description: "Maximum number of lines to read (optional)",
-            default: 1000
+            description: "Maximum number of lines to read from start (default: 500)",
+            default: 500
+          },
+          keyword: {
+            type: "string",
+            description: "Search keyword and return matching lines with context (recommended for large files)"
+          },
+          start_line: {
+            type: "integer",
+            description: "Start line number (1-indexed, e.g., 100 reads from line 100)"
+          },
+          end_line: {
+            type: "integer",
+            description: "End line number (1-indexed, e.g., 200 reads up to line 200)"
           }
         },
         required: ["path"]
@@ -27,7 +39,7 @@ module Clacky
       
 
 
-      def execute(path:, max_lines: 1000)
+      def execute(path:, max_lines: 500, keyword: nil, start_line: nil, end_line: nil)
         # Expand ~ to home directory
         expanded_path = File.expand_path(path)
         
@@ -57,17 +69,63 @@ module Clacky
           if binary_file?(expanded_path)
             return handle_binary_file(expanded_path)
           end
-          
-          # Read text file
-          lines = File.readlines(expanded_path).first(max_lines)
-          content = lines.join
-          truncated = File.readlines(expanded_path).size > max_lines
+
+          # Handle keyword search with context
+          if keyword && !keyword.empty?
+            return find_with_context(expanded_path, keyword)
+          end
+
+          # Read text file with optional line range
+          all_lines = File.readlines(expanded_path)
+          total_lines = all_lines.size
+
+          # Calculate start index (convert 1-indexed to 0-indexed)
+          start_idx = start_line ? [start_line - 1, 0].max : 0
+
+          # Calculate end index based on parameters
+          if end_line
+            # User specified end_line directly
+            end_idx = [end_line - 1, total_lines - 1].min
+          elsif start_line
+            # start_line + max_lines - 1 (relative to start_line, inclusive)
+            calculated_end_line = start_line + max_lines - 1
+            end_idx = [calculated_end_line - 1, total_lines - 1].min
+          else
+            # Read from beginning with max_lines limit
+            end_idx = [max_lines - 1, total_lines - 1].min
+          end
+
+          # Check if start_line exceeds file length first
+          if start_idx >= total_lines
+            return {
+              path: expanded_path,
+              content: nil,
+              lines_read: 0,
+              error: "Invalid line range: start_line #{start_line} exceeds total lines (#{total_lines})"
+            }
+          end
+
+          # Validate range
+          if start_idx > end_idx
+            return {
+              path: expanded_path,
+              content: nil,
+              lines_read: 0,
+              error: "Invalid line range: start_line #{start_line} > end_line #{end_line || (start_line + max_lines)}"
+            }
+          end
+
+          lines = all_lines[start_idx..end_idx] || []
+          truncated = total_lines > max_lines && !keyword
 
           {
             path: expanded_path,
-            content: content,
+            content: lines.join,
             lines_read: lines.size,
+            total_lines: total_lines,
             truncated: truncated,
+            start_line: start_line,
+            end_line: end_line,
             error: nil
           }
         rescue StandardError => e
@@ -157,6 +215,51 @@ module Clacky
         result
       end
 
+      # Find lines matching keyword with context (5 lines before and after each match)
+      private def find_with_context(path, keyword)
+        context_lines_count = 5
+        all_lines = File.readlines(path)
+        total_lines = all_lines.size
+        matches = []
+
+        # Find all matching line indices (case-insensitive)
+        all_lines.each_with_index do |line, index|
+          if line.include?(keyword)
+            start_idx = [index - context_lines_count, 0].max
+            end_idx = [index + context_lines_count, total_lines - 1].min
+            matches << {
+              line_number: index + 1,
+              content: all_lines[start_idx..end_idx].join,
+              start_line: start_idx + 1,
+              end_line: end_idx + 1,
+              match_line: index + 1
+            }
+          end
+        end
+
+        if matches.empty?
+          {
+            path: path,
+            content: nil,
+            matches_count: 0,
+            error: "Keyword '#{keyword}' not found in file"
+          }
+        else
+          # Combine all matches with separator
+          combined_content = matches.map do |m|
+            "... Lines #{m[:start_line]}-#{m[:end_line]} (match at line #{m[:line_number]}):\n#{m[:content]}"
+          end.join("\n---\n")
+
+          {
+            path: path,
+            content: combined_content,
+            matches_count: matches.size,
+            keyword: keyword,
+            error: nil
+          }
+        end
+      end
+
       private def binary_file?(path)
         # Use FileProcessor to detect binary files
         File.open(path, 'rb') do |file|

data/lib/clacky/tools/glob.rb

@@ -39,6 +39,9 @@ module Clacky
           return { error: "Pattern cannot be empty" }
         end
 
+        # Expand ~ in pattern to user's home directory
+        pattern = pattern.gsub("~", Dir.home)
+
         # Validate base_path
         unless Dir.exist?(base_path)
           return { error: "Base path does not exist: #{base_path}" }
@@ -59,8 +62,12 @@ module Clacky
             ignored: 0
           }
 
-          # Change to base path and find matches
-          full_pattern = File.join(base_path, pattern)
+          # Build full pattern - handle absolute paths correctly
+          full_pattern = if File.absolute_path?(pattern)
+                          pattern
+                        else
+                          File.join(base_path, pattern)
+                        end
           all_matches = Dir.glob(full_pattern, File::FNM_DOTMATCH)
                            .reject { |path| File.directory?(path) }
                            .reject { |path| path.end_with?(".", "..") }