openclacky 0.7.0 → 0.7.2

data/lib/clacky/skill.rb

@@ -18,12 +18,17 @@ module Clacky
       agent
       argument-hint
       hooks
+      fork_agent
+      model
+      forbidden_tools
+      auto_summarize
     ].freeze
 
     attr_reader :directory, :frontmatter, :source_path
     attr_reader :name, :description, :content
     attr_reader :disable_model_invocation, :user_invocable
     attr_reader :allowed_tools, :context, :agent_type, :argument_hint, :hooks
+    attr_reader :fork_agent, :model, :forbidden_tools, :auto_summarize
 
     # @param directory [Pathname, String] Path to the skill directory
     # @param source_path [Pathname, String, nil] Optional source path for priority resolution
@@ -52,10 +57,28 @@ module Clacky
       !@disable_model_invocation
     end
 
-    # Check if skill runs in a forked subagent context
+    # Check if this skill should fork a subagent
     # @return [Boolean]
-    def forked_context?
-      @context == "fork"
+    def fork_agent?
+      @fork_agent == true
+    end
+
+    # Get the model to use for the subagent (if fork_agent is true)
+    # @return [String, nil]
+    def subagent_model
+      @model
+    end
+
+    # Get the list of forbidden tools for the subagent
+    # @return [Array<String>]
+    def forbidden_tools_list
+      @forbidden_tools || []
+    end
+
+    # Check if subagent should auto-summarize results
+    # @return [Boolean]
+    def auto_summarize?
+      @auto_summarize != false
     end
 
     # Get the slash command for this skill
@@ -101,6 +124,16 @@ module Clacky
         processed_content.gsub!(placeholder, output.to_s)
       end
 
+      # Append supporting files list if any exist
+      if has_supporting_files?
+        processed_content += "\n\n## Supporting Files\n\n"
+        processed_content += "The following files are available in this skill's directory:\n\n"
+        supporting_files.each do |file|
+          relative_path = file.relative_path_from(@directory)
+          processed_content += "- `#{relative_path}`\n"
+        end
+      end
+
       processed_content
     end
 
@@ -114,7 +147,9 @@ module Clacky
         source_path: @source_path.to_s,
         user_invocable: user_invocable?,
         model_invocation_allowed: model_invocation_allowed?,
-        forked_context: forked_context?,
+        fork_agent: fork_agent?,
+        subagent_model: @model,
+        forbidden_tools: @forbidden_tools,
         allowed_tools: @allowed_tools,
         argument_hint: @argument_hint,
         content_length: @content.length
@@ -179,6 +214,12 @@ module Clacky
       @agent_type = @frontmatter["agent"]
       @argument_hint = @frontmatter["argument-hint"]
       @hooks = @frontmatter["hooks"]
+      
+      # Subagent configuration
+      @fork_agent = @frontmatter["fork_agent"]
+      @model = @frontmatter["model"]
+      @forbidden_tools = @frontmatter["forbidden_tools"]
+      @auto_summarize = @frontmatter["auto_summarize"]
     end
 
     def validate_frontmatter
@@ -193,9 +234,9 @@ module Clacky
         end
       end
 
-      # Validate context
-      if @context && @context != "fork"
-        raise Clacky::AgentError, "Invalid context '#{@context}'. Only 'fork' is supported."
+      # Validate forbidden_tools format
+      if @forbidden_tools && !@forbidden_tools.is_a?(Array)
+        raise Clacky::AgentError, "forbidden_tools must be an array of tool names"
       end
 
       # Validate allowed-tools format

data/lib/clacky/skill_loader.rb

@@ -127,6 +127,13 @@ module Clacky
       @skills_by_command[command]
     end
 
+    # Find a skill by its name (identifier)
+    # @param name [String] Skill identifier (e.g., "code-explorer", "pptx")
+    # @return [Skill, nil]
+    def find_by_name(name)
+      @skills[name]
+    end
+
     # Get skills that can be invoked by user
     # @return [Array<Skill>]
     def user_invocable_skills

data/lib/clacky/tools/edit.rb

@@ -46,22 +46,16 @@ module Clacky
           content = File.read(path)
           original_content = content.dup
 
-          # 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
+          # Find matching string using layered strategy
+          match_result = find_match(content, old_string)
+          
+          unless match_result
+            # Provide helpful error with context
+            return build_helpful_error(content, old_string, path)
           end
+          
+          actual_old_string = match_result[:matched_string]
+          occurrences = match_result[:occurrences]
 
           # If not replace_all and multiple occurrences, warn about ambiguity
           if !replace_all && occurrences > 1
@@ -93,54 +87,117 @@ 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 matching string using layered strategy
+      private def find_match(content, old_string)
+        # Generate candidate strings with different transformations
+        candidates = generate_candidates(old_string)
         
-        # Find all potential matches in content with normalized whitespace
-        matches = []
-        content_lines = content.lines
-        old_lines = old_string.lines
+        # Try simple string matching for each candidate
+        candidates.each do |candidate|
+          next if candidate.empty?
+          if content.include?(candidate)
+            return {
+              matched_string: candidate,
+              occurrences: content.scan(candidate).length
+            }
+          end
+        end
         
-        return nil if old_lines.empty?
+        # If simple matching fails, try smart line-by-line matching (allows leading whitespace differences)
+        try_smart_match(content, old_string)
+      end
+      
+      # Generate candidate strings by applying different transformations
+      private def generate_candidates(old_string)
+        trimmed = old_string.strip
+        unescaped = unescape_over_escaped(old_string)
+        unescaped_trimmed = unescape_over_escaped(trimmed)
         
-        # 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
+        [
+          old_string,           # Original
+          trimmed,              # Trim leading/trailing whitespace
+          unescaped,            # Unescape over-escaped sequences
+          unescaped_trimmed     # Combined: trim + unescape
+        ].uniq # Remove duplicates
+      end
+
+      private def try_smart_match(content, old_string)
+        # Smart matching: allows leading whitespace differences (tabs vs spaces)
+        # Also tries with unescaped versions of old_string
+        
+        candidates = generate_candidates(old_string)
+        
+        candidates.each do |candidate|
+          next if candidate.empty?
+          
+          candidate_lines = candidate.lines
+          next if candidate_lines.empty?
           
-          # 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 }
+          # Find all potential matches in content with normalized whitespace
+          matches = []
+          content_lines = content.lines
+          
+          # Scan through content to find matches
+          (0..content_lines.length - candidate_lines.length).each do |start_idx|
+            slice = content_lines[start_idx, candidate_lines.length]
+            next unless slice
+            
+            # Check if this slice matches when normalized
+            if lines_match_normalized?(slice, candidate_lines)
+              matched_string = slice.join
+              matches << { start: start_idx, matched_string: matched_string }
+            end
+          end
+          
+          # If we found matches with this candidate, return it
+          unless matches.empty?
+            return {
+              matched_string: matches.first[:matched_string],
+              occurrences: matches.length
+            }
           end
         end
         
-        return nil if matches.empty?
-        
-        # Return the first match and count total occurrences
-        {
-          matched_string: matches.first[:matched_string],
-          occurrences: matches.length
-        }
+        # No matches found
+        nil
       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
+          # Normalize leading whitespace and trailing newlines for comparison
+          norm1 = line1.sub(/^\s+/, ' ').chomp
+          norm2 = line2.sub(/^\s+/, ' ').chomp
+          
+          # Try exact match first, then try with unescaping over-escaped sequences
+          norm1 == norm2 || norm1 == unescape_over_escaped(norm2)
         end
       end
 
+      private def unescape_over_escaped(str)
+        # Convert over-escaped sequences back to normal escape sequences
+        # This handles common cases where AI double-escapes backslashes
+        result = str.dup
+        
+        # Handle Unicode escapes: \uXXXX -> actual Unicode character
+        # Example: "\u000C" (literal backslash-u) -> form feed character
+        result = result.gsub(/\\u([0-9a-fA-F]{4})/) { [$1.hex].pack('U') }
+        
+        # Handle common escape sequences
+        result = result.gsub('\\n', "\n")
+        result = result.gsub('\\t', "\t")
+        result = result.gsub('\\r', "\r")
+        result = result.gsub('\\f', "\f")
+        result = result.gsub('\\b', "\b")
+        result = result.gsub('\\v', "\v")
+        result = result.gsub('\\"', '"')
+        result = result.gsub('\\\\', '\\')
+        
+        result
+      end
+
       private def build_helpful_error(content, old_string, path)
         # Find similar content to help debug
         old_lines = old_string.lines
@@ -174,7 +231,7 @@ module Clacky
               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."
+                     "TIP: Use file_reader to see the actual content, then retry. No need to explain, just execute the tools."
             }
           end
         end
@@ -183,7 +240,7 @@ module Clacky
         {
           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."
+                 "TIP: Use file_reader to view the exact content first, then retry. No need to explain, just execute the tools."
         }
       end
 

data/lib/clacky/tools/file_reader.rb

@@ -7,7 +7,7 @@ module Clacky
   module Tools
     class FileReader < Base
       self.tool_name = "file_reader"
-      self.tool_description = "Read contents of a file from the filesystem"
+      self.tool_description = "Read contents of a file from the filesystem."
       self.tool_category = "file_system"
       self.tool_parameters = {
         type: "object",
@@ -21,10 +21,6 @@ module Clacky
             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)"
@@ -36,16 +32,22 @@ module Clacky
         },
         required: ["path"]
       }
-      
+
 
 
       # Maximum text file size (1MB)
       MAX_TEXT_FILE_SIZE = 1 * 1024 * 1024
 
-      def execute(path:, max_lines: 500, keyword: nil, start_line: nil, end_line: nil)
+      # Maximum content size to return (~10,000 tokens = ~40,000 characters)
+      MAX_CONTENT_CHARS = 40_000
+
+      # Maximum characters per line (prevent single huge lines from bloating tokens)
+      MAX_LINE_CHARS = 1000
+
+      def execute(path:, max_lines: 500, start_line: nil, end_line: nil)
         # Expand ~ to home directory
         expanded_path = File.expand_path(path)
-        
+
         unless File.exist?(expanded_path)
           return {
             path: expanded_path,
@@ -84,11 +86,6 @@ module Clacky
             }
           end
 
-          # 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
@@ -130,11 +127,30 @@ module Clacky
           end
 
           lines = all_lines[start_idx..end_idx] || []
-          truncated = total_lines > max_lines && !keyword
+
+          # Truncate individual lines that are too long
+          lines = lines.map do |line|
+            if line.length > MAX_LINE_CHARS
+              line[0...MAX_LINE_CHARS] + "... [Line truncated - #{line.length} chars]\n"
+            else
+              line
+            end
+          end
+
+          content = lines.join
+          truncated = end_idx < (total_lines - 1)
+
+          # Truncate total content if it exceeds maximum size
+          if content.length > MAX_CONTENT_CHARS
+            content = content[0...MAX_CONTENT_CHARS] +
+                     "\n\n[Content truncated - exceeded #{MAX_CONTENT_CHARS} characters (~10,000 tokens)]" +
+                     "\nUse start_line/end_line parameters to read specific sections, or grep tool to search for keywords."
+            truncated = true
+          end
 
           {
             path: expanded_path,
-            content: lines.join,
+            content: content,
             lines_read: lines.size,
             total_lines: total_lines,
             truncated: truncated,
@@ -171,7 +187,7 @@ module Clacky
         if result[:binary] || result['binary']
           format_type = result[:format] || result['format'] || 'unknown'
           size = result[:size_bytes] || result['size_bytes'] || 0
-          
+
           # Check if it has base64 data (LLM-compatible format)
           if result[:base64_data] || result['base64_data']
             size_warning = size > 5_000_000 ? " (WARNING: large file)" : ""
@@ -186,7 +202,7 @@ module Clacky
         truncated = result[:truncated] || result['truncated']
         "Read #{lines} lines#{truncated ? ' (truncated)' : ''}"
       end
-      
+
       # Format result for LLM - handles both text and binary (image/PDF) content
       # This method is called by the agent to format tool results before sending to LLM
       def format_result_for_llm(result)
@@ -194,12 +210,12 @@ module Clacky
         if result[:binary] && result[:base64_data]
           # Create a text description
           description = "File: #{result[:path]}\nType: #{result[:format]}\nSize: #{format_file_size(result[:size_bytes])}"
-          
+
           # Add size warning for large files
           if result[:size_bytes] > 5_000_000
             description += "\nWARNING: Large file (>5MB) - may consume significant tokens"
           end
-          
+
           # For images, return both description and image content
           if result[:mime_type]&.start_with?("image/")
             return {
@@ -212,7 +228,7 @@ module Clacky
               description: description
             }
           end
-          
+
           # For PDFs and other binary formats, just return metadata with base64
           return {
             type: "document",
@@ -224,56 +240,11 @@ module Clacky
             description: description
           }
         end
-        
+
         # For other cases, return the result as-is (agent will JSON.generate it)
         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 handle_binary_file(path)
         # Check if it's a supported format using FileProcessor
         if Utils::FileProcessor.supported_binary_file?(path)
@@ -316,11 +287,11 @@ module Clacky
           }
         end
       end
-      
+
       private def detect_mime_type(path, data)
         Utils::FileProcessor.detect_mime_type(path, data)
       end
-      
+
       private def format_file_size(bytes)
         if bytes < 1024
           "#{bytes} bytes"
@@ -337,11 +308,11 @@ module Clacky
       private def list_directory_contents(path)
         begin
           entries = Dir.entries(path).reject { |entry| entry == "." || entry == ".." }
-          
+
           # Separate files and directories
           files = []
           directories = []
-          
+
           entries.each do |entry|
             full_path = File.join(path, entry)
             if File.directory?(full_path)
@@ -350,15 +321,15 @@ module Clacky
               files << entry
             end
           end
-          
+
           # Sort directories and files separately, then combine
           directories.sort!
           files.sort!
           all_entries = directories + files
-          
+
           # Format as a tree-like structure
           content = all_entries.map { |entry| "  #{entry}" }.join("\n")
-          
+
           {
             path: path,
             content: "Directory listing:\n#{content}",

data/lib/clacky/tools/invoke_skill.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    # Tool for invoking skills within the agent
+    # This allows the AI to call skills as tools rather than requiring explicit user commands
+    class InvokeSkill < Base
+      self.tool_name = "invoke_skill"
+      self.tool_description = "Invoke a specialized skill to handle specific tasks. Use this when user's request matches a skill's purpose (e.g., code exploration, document creation, etc.). This will read the skill's instructions and execute them appropriately (either inline or in a subagent)."
+      self.tool_category = "skill_management"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          skill_name: {
+            type: "string",
+            description: "Name of the skill to invoke (e.g., 'code-explorer', 'pptx', 'pdf')"
+          },
+          task: {
+            type: "string",
+            description: "The task or query to pass to the skill"
+          }
+        },
+        required: ["skill_name", "task"]
+      }
+
+      # Execute the skill invocation
+      # @param skill_name [String] Name of the skill to invoke
+      # @param task [String] Task description to pass to the skill
+      # @param agent [Clacky::Agent] Agent instance (injected)
+      # @param skill_loader [Clacky::SkillLoader] Skill loader instance (injected)
+      # @return [Hash] Result of skill execution
+      def execute(skill_name:, task:, agent: nil, skill_loader: nil)
+        # Validate injected dependencies
+        return { error: "Agent context is required" } unless agent
+        return { error: "Skill loader is required" } unless skill_loader
+
+        # Find skill by name
+        skill = skill_loader.find_by_name(skill_name)
+        return { error: "Skill not found: #{skill_name}" } unless skill
+
+        # Check if skill allows model invocation
+        unless skill.model_invocation_allowed?
+          return { error: "Skill '#{skill_name}' does not allow model invocation" }
+        end
+
+        # Execute skill based on its configuration
+        if skill.fork_agent?
+          # Execute in subagent - use private method via send
+          result = agent.send(:execute_skill_with_subagent, skill, task)
+          {
+            message: "Skill '#{skill_name}' executed in subagent",
+            result: result,
+            skill_type: "subagent"
+          }
+        else
+          # Expand skill content inline
+          expanded = skill.process_content(task)
+          {
+            message: "Skill '#{skill_name}' content expanded",
+            content: expanded,
+            skill_type: "inline",
+            note: "The expanded content has been added to the conversation. Continue following its instructions."
+          }
+        end
+      end
+
+      # Format the tool call for display
+      # @param args [Hash] Tool arguments
+      # @return [String] Formatted call description
+      def format_call(args)
+        skill = args[:skill_name] || args["skill_name"]
+        "InvokeSkill(#{skill})"
+      end
+
+      # Format the tool result for display
+      # @param result [Hash] Tool execution result
+      # @return [String] Formatted result summary
+      def format_result(result)
+        if result[:error]
+          "Error: #{result[:error]}"
+        elsif result[:skill_type] == "subagent"
+          "Subagent executed successfully"
+        else
+          "Skill content expanded"
+        end
+      end
+    end
+  end
+end