openclacky 0.6.2 → 0.6.3

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::Error,
+          "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::Error, "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::Error => 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/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/grep.rb

@@ -59,11 +59,6 @@ module Clacky
             description: "Maximum file size in bytes to search (default: 1MB)",
             default: MAX_FILE_SIZE
           },
-          max_files_to_search: {
-            type: "integer",
-            description: "Maximum number of files to search",
-            default: 500
-          }
         },
         required: %w[pattern]
       }
@@ -78,7 +73,7 @@ module Clacky
         max_matches_per_file: 50,
         max_total_matches: 200,
         max_file_size: MAX_FILE_SIZE,
-        max_files_to_search: 500
+        max_files_to_search: 10000
       )
         # Validate pattern
         if pattern.nil? || pattern.strip.empty?
@@ -135,7 +130,7 @@ module Clacky
             end
 
             # Skip if file should be ignored (unless it's a config file)
-            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) && 
+            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) &&
                !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
               skipped[:ignored] += 1
               next
@@ -217,12 +212,12 @@ module Clacky
           matches = result[:total_matches] || 0
           files = result[:files_with_matches] || 0
           msg = "[OK] Found #{matches} matches in #{files} files"
-          
+
           # Add truncation info if present
           if result[:truncated] && result[:truncation_reason]
             msg += " (truncated: #{result[:truncation_reason]})"
           end
-          
+
           msg
         end
       end
@@ -275,12 +270,12 @@ module Clacky
 
       def search_file(file, regex, context_lines, max_matches)
         matches = []
-        
+
         # Use File.foreach for memory-efficient line-by-line reading
         File.foreach(file, chomp: true).with_index do |line, index|
           # Stop if we have enough matches for this file
           break if matches.length >= max_matches
-          
+
           next unless line.match?(regex)
 
           # Truncate long lines
@@ -315,10 +310,10 @@ module Clacky
         (start_line..end_line).each do |i|
           line_content = lines[i]
           # Truncate long lines in context too
-          display_content = line_content.length > MAX_LINE_LENGTH ? 
-                          "#{line_content[0...MAX_LINE_LENGTH]}..." : 
+          display_content = line_content.length > MAX_LINE_LENGTH ?
+                          "#{line_content[0...MAX_LINE_LENGTH]}..." :
                           line_content
-          
+
           context << {
             line_number: i + 1,
             content: display_content,

data/lib/clacky/tools/safe_shell.rb

@@ -32,20 +32,26 @@ module Clacky
         required: ["command"]
       }
 
-      def execute(command:, timeout: nil, max_output_lines: 1000)
+      def execute(command:, timeout: nil, max_output_lines: 1000, skip_safety_check: false)
         # Get project root directory
         project_root = Dir.pwd
 
         begin
           # 1. Extract timeout from command if it starts with "timeout N"
           command, extracted_timeout = extract_timeout_from_command(command)
-          
+
           # Use extracted timeout if not explicitly provided
           timeout ||= extracted_timeout
 
-          # 2. Use safety replacer to process command
-          safety_replacer = CommandSafetyReplacer.new(project_root)
-          safe_command = safety_replacer.make_command_safe(command)
+          # 2. Use safety replacer to process command (skip if user already confirmed)
+          if skip_safety_check
+            # User has confirmed, execute command as-is (no safety modifications)
+            safe_command = command
+            safety_replacer = nil
+          else
+            safety_replacer = CommandSafetyReplacer.new(project_root)
+            safe_command = safety_replacer.make_command_safe(command)
+          end
 
           # 3. Calculate timeouts: soft_timeout is fixed at 5s, hard_timeout from timeout parameter
           soft_timeout = 5
@@ -55,7 +61,7 @@ module Clacky
           result = super(command: safe_command, soft_timeout: soft_timeout, hard_timeout: hard_timeout, max_output_lines: max_output_lines)
 
           # 5. Enhance result information
-          enhance_result(result, command, safe_command)
+          enhance_result(result, command, safe_command, safety_replacer)
 
         rescue SecurityError => e
           # Security error, return friendly error message
@@ -145,9 +151,9 @@ module Clacky
         end
       end
 
-      def enhance_result(result, original_command, safe_command)
+      def enhance_result(result, original_command, safe_command, safety_replacer = nil)
         # If command was replaced, add security information
-        if original_command != safe_command
+        if safety_replacer && original_command != safe_command
           result[:security_enhanced] = true
           result[:original_command] = original_command
           result[:safe_command] = safe_command