octo-agent 0.11.2

data/lib/octo/agent/skill_reflector.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Octo
+  class Agent
+    # Scenario 2: Reflect on skill execution and suggest improvements.
+    #
+    # After a skill completes, forks a subagent to analyze:
+    #   - Were instructions clear enough?
+    #   - Any missing edge cases?
+    #   - Any improvements needed?
+    #
+    # If the LLM identifies concrete improvements, it invokes skill-creator
+    # to update the skill.
+    module SkillReflector
+      # Minimum iterations for a skill execution to warrant reflection.
+      # This counts iterations within the skill execution only, not session-cumulative.
+      MIN_SKILL_ITERATIONS = 5
+
+      # Check if we should reflect on the skill that just executed
+      # Called from SkillEvolution#run_skill_evolution_hooks
+      def maybe_reflect_on_skill
+        return unless @skill_execution_context
+
+        # Only reflect on skills that the user explicitly invoked via slash command.
+        # Skills triggered by the LLM itself (e.g. as part of a broader task) or
+        # platform-management skills invoked incidentally should not be reflected on.
+        return unless @skill_execution_context[:slash_command]
+
+        # Skip default skills — they are system-owned and should not be
+        # auto-improved by the evolution system.
+        source = @skill_execution_context[:source]
+        return if source == :default
+
+        skill_name = @skill_execution_context[:skill_name]
+        start_iteration = @skill_execution_context[:start_iteration]
+        
+        # Calculate iterations within the skill execution (not session-cumulative)
+        iterations = @iterations - start_iteration
+
+        # Only reflect if the skill actually ran for a meaningful number of iterations
+        return if iterations < MIN_SKILL_ITERATIONS
+
+        # Fork an isolated subagent to reflect + improve — does NOT touch main history
+        @ui&.show_info("Reflecting on skill execution: #{skill_name}")
+        subagent = fork_subagent
+        result = subagent.run(build_skill_reflection_prompt(skill_name))
+
+        # Clear the context so we don't reflect again
+        @skill_execution_context = nil
+      end
+
+      # Build the reflection prompt content
+      # @param skill_name [String]
+      # @return [String]
+      private def build_skill_reflection_prompt(skill_name)
+        <<~PROMPT
+          ═══════════════════════════════════════════════════════════════
+          SKILL REFLECTION MODE
+          ═══════════════════════════════════════════════════════════════
+          You just executed the skill "#{skill_name}".
+
+          ## Quick Analysis
+
+          Reflect on whether the skill could be improved:
+          - Were the instructions clear enough?
+          - Did you encounter any edge cases not covered?
+          - Were there any steps that could be streamlined?
+          - Is there missing context that would make it easier next time?
+          - Did the skill produce the expected results?
+
+          ## Decision
+
+          If you identified **concrete, actionable improvements**:
+            → Call invoke_skill("skill-creator", task: "Improve skill #{skill_name}: [describe specific improvements needed]")
+
+          If the skill worked well as-is:
+            → Respond briefly: "Skill #{skill_name} worked well, no improvements needed."
+
+          ## Constraints
+
+          - DO NOT spend more than 30 seconds on this reflection
+          - Be specific and actionable in your improvement suggestions
+          - Only suggest improvements that would make a meaningful difference
+          - If you're unsure, err on the side of "no improvements needed"
+        PROMPT
+      end
+    end
+  end
+end

data/lib/octo/agent/system_prompt_builder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "../utils/workspace_rules"
+
+module Octo
+  class Agent
+    # System prompt construction
+    # Builds system prompt by composing layers:
+    #   1. Agent-specific system_prompt.md  (role & responsibilities)
+    #   2. base_prompt.md                   (universal rules: todo manager, tool usage, etc.)
+    #   3. Project rules                    (.octorules / .cursorrules / CLAUDE.md)
+    #   4. SOUL.md                          (agent personality — user override or built-in default)
+    #   5. USER.md                          (user profile — user override or built-in default)
+    #   6. Skills context                   (available skills list)
+    module SystemPromptBuilder
+      # Max characters loaded from each agent file (SOUL.md / USER.md)
+      MAX_MEMORY_FILE_CHARS = 1000
+
+      # Build complete system prompt with project rules and skills
+      # @return [String] Complete system prompt
+      def build_system_prompt
+        parts = []
+
+        # Layer 1: agent-specific role & responsibilities
+        parts << @agent_profile.system_prompt
+
+        # Layer 2: universal behavioral rules (todo manager, tool usage, etc.)
+        base = @agent_profile.base_prompt
+        parts << base unless base.empty?
+
+        # Layer 3: project-specific rules from working directory
+        project_rules = load_project_rules
+        if project_rules
+          parts << format_section("PROJECT-SPECIFIC RULES (from #{project_rules[:source]})",
+                                  project_rules[:content],
+                                  footer: "IMPORTANT: Follow these project-specific rules at all times!")
+        end
+
+        # Layer 4 & 5: SOUL.md and USER.md (with built-in defaults as fallback)
+        soul = truncate(@agent_profile.soul, MAX_MEMORY_FILE_CHARS)
+        parts << format_section("AGENT SOUL (from ~/.octo/agents/SOUL.md)", soul) unless soul.empty?
+
+        user_profile = truncate(@agent_profile.user_profile, MAX_MEMORY_FILE_CHARS)
+        parts << format_section("USER PROFILE (from ~/.octo/agents/USER.md)", user_profile) unless user_profile.empty?
+
+        # Layer 6: skills context
+        skill_context = build_skill_context
+        parts << skill_context if skill_context && !skill_context.empty?
+
+        parts.join("\n\n")
+      end
+
+      private def load_project_rules
+        main = Utils::WorkspaceRules.find_main(@working_dir)
+        sub_projects = Utils::WorkspaceRules.find_sub_projects(@working_dir)
+
+        return nil if main.nil? && sub_projects.empty?
+
+        combined_content = []
+        combined_content << main[:content] if main
+
+        unless sub_projects.empty?
+          n = Utils::WorkspaceRules::SUB_PROJECT_SUMMARY_LINES
+          summaries = sub_projects.map do |sp|
+            <<~SECTION.strip
+              ### Sub-project: #{sp[:sub_name]}/
+              Summary (first #{n} lines of #{sp[:relative_path]}):
+              #{sp[:summary]}
+              > IMPORTANT: Before working on any files under #{sp[:sub_name]}/, read the full rules file at `#{sp[:relative_path]}` using file_reader.
+            SECTION
+          end
+
+          combined_content << <<~BLOCK.strip
+            ## SUB-PROJECT AGENTS
+            This workspace contains sub-projects, each with their own rules.
+            When working in a sub-project, you MUST read its full .octorules first.
+
+            #{summaries.join("\n\n")}
+          BLOCK
+        end
+
+        source = main ? main[:name] : "sub-projects"
+        { content: combined_content.join("\n\n"), source: source }
+      end
+
+      private def format_section(title, content, footer: nil)
+        sep = "=" * 80
+        lines = ["", sep, title, sep, content, sep]
+        lines << footer if footer
+        lines << sep if footer
+        lines.join("\n")
+      end
+
+      private def truncate(text, max_chars)
+        return text if text.length <= max_chars
+
+        text[0, max_chars] + "\n... [truncated]"
+      end
+    end
+  end
+end

data/lib/octo/agent/time_machine.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Octo
+  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
+
+        # Claim ownership of this task for the current thread.
+        # If a stale thread (e.g. a slow subagent) wakes up later it will see
+        # @task_thread != Thread.current via check_stale! and self-terminate
+        # before it can write to history.
+        @task_thread = Thread.current
+
+        @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,
+          ".octo",
+          "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,
+            ".octo",
+            "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.
+      # Returns API-ready array (strips internal fields + handles orphaned tool_calls).
+      # @param force_reasoning_content_pad [Boolean] forwarded to MessageHistory,
+      #   enables one-shot pad-and-retry for thinking-mode providers that
+      #   require reasoning_content on every assistant message.
+      # Made public for testing
+      def active_messages(force_reasoning_content_pad: false)
+        if @active_task_id == @current_task_id
+          return @history.to_api(force_reasoning_content_pad: force_reasoning_content_pad)
+        end
+
+        stripped = @history.for_task(@active_task_id).map do |msg|
+          msg.reject { |k, _| MessageHistory::INTERNAL_FIELDS.include?(k) }
+        end
+        # Apply the same reasoning_content padding rule used by to_api so
+        # Time Machine replays satisfy thinking-mode providers after a
+        # 400 retry.
+        MessageHistory.pad_reasoning_content_if_needed(stripped, force: force_reasoning_content_pad)
+      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 = @history.to_a.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