openclacky 0.7.0 → 0.7.2

data/lib/clacky/agent/skill_manager.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Skill management and execution
+    # Handles skill loading, command parsing, and subagent execution
+    module SkillManager
+      # Load all skills from configured locations
+      # @return [Array<Skill>]
+      def load_skills
+        @skill_loader.load_all
+      end
+
+      # Check if input is a skill command and process it
+      # @param input [String] User input
+      # @return [Hash, nil] Returns { skill: Skill, arguments: String } if skill command, nil otherwise
+      def parse_skill_command(input)
+        # Check for slash command pattern
+        if input.start_with?("/")
+          # Extract command and arguments
+          match = input.match(%r{^/(\S+)(?:\s+(.*))?$})
+          return nil unless match
+
+          skill_name = match[1]
+          arguments = match[2] || ""
+
+          # Find skill by command
+          skill = @skill_loader.find_by_command("/#{skill_name}")
+          return nil unless skill
+
+          # Check if user can invoke this skill
+          unless skill.user_invocable?
+            return nil
+          end
+
+          { skill: skill, arguments: arguments }
+        else
+          nil
+        end
+      end
+
+      # Execute a skill command
+      # @param input [String] User input (should be a skill command)
+      # @return [String] The expanded prompt with skill content
+      def execute_skill_command(input)
+        parsed = parse_skill_command(input)
+        return input unless parsed
+
+        skill = parsed[:skill]
+        arguments = parsed[:arguments]
+
+        # Check if skill requires forking a subagent
+        if skill.fork_agent?
+          return execute_skill_with_subagent(skill, arguments)
+        end
+
+        # Process skill content with arguments (normal skill execution)
+        expanded_content = skill.process_content(arguments)
+
+        # Log skill usage
+        @ui&.log("Executing skill: #{skill.identifier}", level: :info)
+
+        expanded_content
+      end
+
+      # Generate skill context - loads all auto-invocable skills
+      # @return [String] Skill context to add to system prompt
+      def build_skill_context
+        # Load all auto-invocable skills
+        all_skills = @skill_loader.load_all
+        auto_invocable = all_skills.select(&:model_invocation_allowed?)
+
+        return "" if auto_invocable.empty?
+
+        context = "\n\n" + "=" * 80 + "\n"
+        context += "AVAILABLE SKILLS:\n"
+        context += "=" * 80 + "\n\n"
+        context += "CRITICAL SKILL USAGE RULES:\n"
+        context += "- When user's request matches a skill description, you MUST use invoke_skill tool\n"
+        context += "- NEVER implement skill functionality yourself - always delegate to the skill\n"
+        context += "- Example: invoke_skill(skill_name: 'code-explorer', task: 'Analyze project structure')\n\n"
+        context += "Available skills:\n\n"
+
+        auto_invocable.each do |skill|
+          context += "- name: #{skill.identifier}\n"
+          context += "  description: #{skill.context_description}\n\n"
+        end
+
+        context += "\n"
+        context
+      end
+
+      private
+
+      # Execute a skill in a forked subagent
+      # @param skill [Skill] The skill to execute
+      # @param arguments [String] Arguments for the skill
+      # @return [String] Summary of subagent execution
+      def execute_skill_with_subagent(skill, arguments)
+        # Log subagent fork
+        @ui&.show_info("Subagent start: #{skill.identifier}")
+
+        # Build task content from skill
+        task_content = skill.process_content(arguments)
+
+        # Fork subagent with skill configuration
+        subagent = fork_subagent(
+          model: skill.subagent_model,
+          forbidden_tools: skill.forbidden_tools_list,
+          system_prompt_suffix: task_content
+        )
+
+        # Run subagent
+        result = subagent.run(arguments)
+
+        # Generate summary
+        summary = generate_subagent_summary(subagent)
+
+        # Insert summary back to parent agent messages (replacing the instruction message)
+        # Find and replace the last message with subagent_instructions flag
+        messages_with_instructions = @messages.select { |m| m[:subagent_instructions] }
+        if messages_with_instructions.any?
+          instruction_msg = messages_with_instructions.last
+          instruction_msg[:content] = summary
+          instruction_msg.delete(:subagent_instructions)
+          instruction_msg[:subagent_result] = true
+          instruction_msg[:skill_name] = skill.identifier
+        end
+
+        # Log completion
+        @ui&.show_info("Subagent completed: #{result[:iterations]} iterations, $#{result[:total_cost_usd].round(4)}")
+
+        # Return summary as the skill execution result
+        summary
+      end
+    end
+  end
+end

data/lib/clacky/agent/system_prompt_builder.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # System prompt construction
+    # Builds system prompt with project rules and skill context
+    module SystemPromptBuilder
+      # System prompt for the coding agent
+      SYSTEM_PROMPT = <<~PROMPT.freeze
+        You are OpenClacky, an AI coding assistant and technical co-founder, designed to help non-technical
+        users complete software development projects. You are responsible for development in the current project.
+
+        Your role is to:
+        - Understand project requirements and translate them into technical solutions
+        - Write clean, maintainable, and well-documented code
+        - Follow best practices and industry standards
+        - Explain technical concepts in simple terms when needed
+        - Proactively identify potential issues and suggest improvements
+        - Help with debugging, testing, and deployment
+
+        Working process:
+        1. **For complex tasks with multiple steps**:
+           - Use todo_manager to create a complete TODO list FIRST
+           - After creating the TODO list, START EXECUTING each task immediately
+           - Don't stop after planning - continue to work on the tasks!
+        2. Always read existing code before making changes (use file_reader/glob/grep or invoke code-explorer skill)
+        3. Ask clarifying questions if requirements are unclear
+        4. Break down complex tasks into manageable steps
+        5. **USE TOOLS to create/modify files** - don't just return code
+        6. Write code that is secure, efficient, and easy to understand
+        7. Test your changes using the shell tool when appropriate
+        8. **IMPORTANT**: After completing each step, mark the TODO as completed and continue to the next one
+        9. Keep working until ALL TODOs are completed or you need user input
+        10. Provide brief explanations after completing actions
+
+        IMPORTANT: You should frequently refer to the existing codebase. For unclear instructions,
+        prioritize understanding the codebase first before answering or taking action.
+        Always read relevant code files to understand the project structure, patterns, and conventions.
+
+        CRITICAL RULE FOR TODO MANAGER:
+        When using todo_manager to add tasks, you MUST continue working immediately after adding ALL todos.
+        Adding todos is NOT completion - it's just the planning phase!
+        Workflow: add todo 1 → add todo 2 → add todo 3 → START WORKING on todo 1 → complete(1) → work on todo 2 → complete(2) → etc.
+        NEVER stop after just adding todos without executing them!
+
+        NOTE: Available skills are listed below in the AVAILABLE SKILLS section.
+        When a user's request matches a skill, you MUST use the skill tool instead of implementing it yourself.
+      PROMPT
+
+      # Build complete system prompt with project rules and skills
+      # @return [String] Complete system prompt
+      def build_system_prompt
+        prompt = SYSTEM_PROMPT.dup
+
+        # Try to load project rules from multiple sources (in order of priority)
+        rules_files = [
+          { path: ".clackyrules", name: ".clackyrules" },
+          { path: ".cursorrules", name: ".cursorrules" },
+          { path: "CLAUDE.md", name: "CLAUDE.md" }
+        ]
+
+        rules_content = nil
+        rules_source = nil
+
+        rules_files.each do |file_info|
+          full_path = File.join(@working_dir, file_info[:path])
+          if File.exist?(full_path)
+            content = File.read(full_path).strip
+            unless content.empty?
+              rules_content = content
+              rules_source = file_info[:name]
+              break
+            end
+          end
+        end
+
+        # Add rules to prompt if found
+        if rules_content && rules_source
+          prompt += "\n\n" + "=" * 80 + "\n"
+          prompt += "PROJECT-SPECIFIC RULES (from #{rules_source}):\n"
+          prompt += "=" * 80 + "\n"
+          prompt += rules_content
+          prompt += "\n" + "=" * 80 + "\n"
+          prompt += "⚠️ IMPORTANT: Follow these project-specific rules at all times!\n"
+          prompt += "=" * 80
+        end
+
+        # Add all loaded skills to system prompt
+        skill_context = build_skill_context
+        prompt += skill_context if skill_context && !skill_context.empty?
+
+        prompt
+      end
+    end
+  end
+end

data/lib/clacky/agent/time_machine.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Time Machine module for task history management with undo/redo support
+    # Stores complete file snapshots (AFTER state) to support message compression
+    module TimeMachine
+      # Initialize Time Machine state
+      private def init_time_machine
+        @task_parents ||= {}      # { task_id => parent_id }
+        @current_task_id ||= 0    # Latest created task ID
+        @active_task_id ||= 0     # Current active task ID (for undo/redo)
+      end
+
+      # Start a new task and establish parent relationship
+      # Made public for testing
+      def start_new_task
+        parent_id = @active_task_id
+        @current_task_id += 1
+        @active_task_id = @current_task_id
+        @task_parents[@current_task_id] = parent_id
+
+        @current_task_id
+      end
+
+      # Save snapshots of modified files (AFTER state)
+      # @param modified_files [Array<String>] List of file paths that were modified
+      # Made public for testing
+      def save_modified_files_snapshot(modified_files)
+        return if modified_files.nil? || modified_files.empty?
+
+        snapshot_dir = File.join(
+          Dir.home,
+          ".clacky",
+          "snapshots",
+          @session_id,
+          "task-#{@current_task_id}"
+        )
+        FileUtils.mkdir_p(snapshot_dir)
+
+        modified_files.each do |file_path|
+          next unless File.exist?(file_path)
+
+          # Save file content to snapshot
+          relative_path = file_path.start_with?(@working_dir) ?
+            file_path.sub(@working_dir + "/", "") : File.basename(file_path)
+          
+          snapshot_file = File.join(snapshot_dir, relative_path)
+          FileUtils.mkdir_p(File.dirname(snapshot_file))
+          FileUtils.cp(file_path, snapshot_file)
+        end
+      rescue StandardError => e
+        # Silently handle errors in tests
+      end
+
+      # Restore files to the state at given task
+      # @param task_id [Integer] Target task ID
+      # Made public for testing
+      def restore_to_task_state(task_id)
+        # Collect all modified files from task 1 to target task
+        files_to_restore = {}
+        
+        (1..task_id).each do |tid|
+          snapshot_dir = File.join(
+            Dir.home,
+            ".clacky",
+            "snapshots",
+            @session_id,
+            "task-#{tid}"
+          )
+          
+          next unless Dir.exist?(snapshot_dir)
+          
+          Dir.glob(File.join(snapshot_dir, "**", "*")).each do |snapshot_file|
+            next if File.directory?(snapshot_file)
+            
+            relative_path = snapshot_file.sub(snapshot_dir + "/", "")
+            files_to_restore[relative_path] = snapshot_file
+          end
+        end
+        
+        # Restore files
+        files_to_restore.each do |relative_path, snapshot_file|
+          target_file = File.join(@working_dir, relative_path)
+          FileUtils.mkdir_p(File.dirname(target_file))
+          FileUtils.cp(snapshot_file, target_file)
+        end
+      rescue StandardError => e
+        # Silently handle errors in tests
+        raise
+      end
+
+      # Filter messages to only show tasks up to active_task_id
+      # This hides "future" messages when user has undone
+      # Made public for testing
+      def active_messages
+        return @messages if @active_task_id == @current_task_id
+        
+        @messages.select do |msg|
+          msg_task_id = msg[:task_id] || 0
+          msg_task_id <= @active_task_id
+        end
+      end
+
+      # Undo to parent task
+      def undo_last_task
+        parent_id = @task_parents[@active_task_id]
+        return { success: false, message: "Already at root task" } if parent_id.nil? || parent_id == 0
+
+        restore_to_task_state(parent_id)
+        @active_task_id = parent_id
+
+        {
+          success: true,
+          message: "⏪ Undone to task #{parent_id}",
+          task_id: parent_id
+        }
+      end
+
+      # Switch to specific task (for redo or branch switching)
+      def switch_to_task(target_task_id)
+        if target_task_id > @current_task_id || target_task_id < 1
+          return { success: false, message: "Invalid task ID: #{target_task_id}" }
+        end
+
+        restore_to_task_state(target_task_id)
+        @active_task_id = target_task_id
+
+        {
+          success: true,
+          message: "⏩ Switched to task #{target_task_id}",
+          task_id: target_task_id
+        }
+      end
+
+      # Get children of a task (for branch detection)
+      def get_child_tasks(task_id)
+        @task_parents.select { |_, parent| parent == task_id }.keys
+      end
+
+      # Get task history with summaries for UI display
+      # @param limit [Integer] Maximum number of recent tasks to return
+      # @return [Array<Hash>] Task history with metadata
+      def get_task_history(limit: 10)
+        return [] if @current_task_id == 0
+
+        tasks = []
+        (1..@current_task_id).to_a.reverse.take(limit).reverse.each do |task_id|
+          # Find first user message for this task
+          first_user_msg = @messages.find do |msg|
+            msg[:task_id] == task_id && msg[:role] == "user"
+          end
+
+          summary = if first_user_msg
+            content = extract_message_text(first_user_msg[:content])
+            # Truncate to 60 characters (including "...")
+            content.length > 60 ? "#{content[0...57]}..." : content
+          else
+            "Task #{task_id}"
+          end
+
+          # Determine task status
+          status = if task_id == @active_task_id
+            :current
+          elsif task_id < @active_task_id
+            :past
+          else
+            :future
+          end
+
+          # Check if task has branches (multiple children)
+          children = get_child_tasks(task_id)
+          has_branches = children.length > 1
+
+          tasks << {
+            task_id: task_id,
+            summary: summary,
+            status: status,
+            has_branches: has_branches
+          }
+        end
+
+        tasks
+      end
+
+      # Extract text from message content (handles both string and array formats)
+      private def extract_message_text(content)
+        if content.is_a?(String)
+          content
+        elsif content.is_a?(Array)
+          text_parts = content.select { |part| part[:type] == "text" }
+          text_parts.map { |part| part[:text] }.join(" ")
+        else
+          ""
+        end
+      end
+    end
+  end
+end