octo-agent 0.11.2

data/lib/octo/utils/gitignore_parser.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Octo
+  # Parser for .gitignore files to determine which files should be ignored
+  class GitignoreParser
+    attr_reader :patterns
+
+    def initialize(gitignore_path = nil)
+      @patterns = []
+      @negation_patterns = []
+      
+      if gitignore_path && File.exist?(gitignore_path)
+        parse_gitignore(gitignore_path)
+      end
+    end
+
+    def merge!(other_gitignore_path, prefix: nil)
+      return unless other_gitignore_path && File.exist?(other_gitignore_path)
+
+      File.readlines(other_gitignore_path, chomp: true).each do |line|
+        next if line.strip.empty? || line.start_with?('#')
+
+        negation = line.start_with?('!')
+        raw = negation ? line[1..] : line
+        info = normalize_pattern(raw)
+
+        if prefix
+          original = info[:pattern]
+          original = original[1..] if info[:is_absolute]
+          info[:pattern] = "#{prefix}/#{original}"
+          info[:is_absolute] = false
+        end
+
+        if negation
+          @negation_patterns << info
+        else
+          @patterns << info
+        end
+      end
+    rescue StandardError => e
+      warn "Warning: Failed to merge .gitignore: #{e.message}"
+    end
+
+    # Check if a file path should be ignored
+    def ignored?(path)
+      relative_path = path.start_with?('./') ? path[2..] : path
+      
+      # Check negation patterns first (! prefix in .gitignore)
+      @negation_patterns.each do |pattern|
+        return false if match_pattern?(relative_path, pattern)
+      end
+      
+      # Then check ignore patterns
+      @patterns.each do |pattern|
+        return true if match_pattern?(relative_path, pattern)
+      end
+      
+      false
+    end
+
+
+    def parse_gitignore(path)
+      File.readlines(path, chomp: true).each do |line|
+        # Skip comments and empty lines
+        next if line.strip.empty? || line.start_with?('#')
+        
+        # Handle negation patterns (lines starting with !)
+        if line.start_with?('!')
+          @negation_patterns << normalize_pattern(line[1..])
+        else
+          @patterns << normalize_pattern(line)
+        end
+      end
+    rescue StandardError => e
+      # If we can't parse .gitignore, just continue with empty patterns
+      warn "Warning: Failed to parse .gitignore: #{e.message}"
+    end
+
+    def normalize_pattern(pattern)
+      pattern = pattern.strip
+      
+      # Remove trailing whitespace
+      pattern = pattern.rstrip
+      
+      # Store original for directory detection
+      is_directory = pattern.end_with?('/')
+      pattern = pattern.chomp('/')
+      
+      {
+        pattern: pattern,
+        is_directory: is_directory,
+        is_absolute: pattern.start_with?('/'),
+        has_wildcard: pattern.include?('*') || pattern.include?('?'),
+        has_double_star: pattern.include?('**')
+      }
+    end
+
+    def match_pattern?(path, pattern_info)
+      pattern = pattern_info[:pattern]
+      is_absolute = pattern_info[:is_absolute]
+      
+      # For absolute patterns (starting with /), remove the leading slash
+      # These patterns match from the root of the repository
+      if is_absolute
+        pattern = pattern[1..]
+        # Absolute patterns match exactly from the start of the path
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+      end
+      
+      # Handle directory patterns
+      if pattern_info[:is_directory]
+        # Directory patterns should match the directory and all its contents
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+        # Also check if any path component matches the directory pattern
+        return true if path.split('/').include?(pattern)
+      end
+      
+      # Handle different wildcard patterns
+      if pattern_info[:has_double_star]
+        # Convert ** to match any number of directories
+        regex_pattern = Regexp.escape(pattern)
+          .gsub('\*\*/', '(.*/)?')  # **/ matches zero or more directories
+          .gsub('\*\*', '.*')        # ** at end matches anything
+          .gsub('\*', '[^/]*')       # * matches anything except /
+          .gsub('\?', '[^/]')        # ? matches single character except /
+        
+        regex = Regexp.new("^#{regex_pattern}$")
+        return true if path.match?(regex)
+        return true if path.split('/').any? { |part| part.match?(regex) }
+      elsif pattern_info[:has_wildcard]
+        # Convert glob pattern to regex
+        regex_pattern = Regexp.escape(pattern)
+          .gsub('\*', '[^/]*')
+          .gsub('\?', '[^/]')
+        
+        regex = Regexp.new("^#{regex_pattern}$")
+        return true if path.match?(regex)
+        return true if File.basename(path).match?(regex)
+      else
+        # Exact match - pattern without wildcards
+        # Match as basename or as path prefix
+        return true if path == pattern
+        return true if path.start_with?("#{pattern}/")
+        return true if File.basename(path) == pattern
+        # Also check if pattern matches any path component
+        return true if path.split('/').include?(pattern)
+      end
+      
+      false
+    end
+  end
+end

data/lib/octo/utils/limit_stack.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Octo
+  module Utils
+    # Auto-rolling fixed-size array.
+    # Automatically discards oldest elements when the line-count limit is exceeded.
+    #
+    # Optional limits (all default to nil = no limit):
+    #   max_line_chars – truncate each individual line to this many characters on push
+    #   max_chars      – once the total accepted chars reach this threshold, further
+    #                    pushes are silently dropped (sets #truncated? = true)
+    #
+    # These extra limits are fully opt-in; existing callers that only pass max_size
+    # are completely unaffected.
+    class LimitStack
+      attr_reader :max_size, :items
+
+      def initialize(max_size: 5000, max_line_chars: nil, max_chars: nil)
+        @max_size       = max_size
+        @max_line_chars = max_line_chars
+        @max_chars      = max_chars
+
+        @items          = []
+        @total_chars    = 0   # chars currently stored in @items
+        @truncated      = false
+        @chars_full     = false  # latched true once max_chars is reached
+      end
+
+      # True if any content was dropped (lines rolled off the front OR
+      # chars budget was exceeded OR a line was truncated).
+      def truncated?
+        @truncated
+      end
+
+      # Add elements (supports single or multiple)
+      def push(*elements)
+        elements.each do |element|
+          _push_one(element)
+        end
+        self
+      end
+      alias_method :<<, :push
+
+      # Add multi-line text (split by lines and add)
+      def push_lines(text)
+        return self if text.nil? || text.empty?
+
+        lines = text.is_a?(Array) ? text : text.lines
+        lines.each { |line| _push_one(line) }
+        self
+      end
+
+      # Remove and return the last element
+      def pop
+        item = @items.pop
+        @total_chars -= item.length if item.is_a?(String)
+        item
+      end
+
+      # Get last N elements
+      def last(n = nil)
+        n ? @items.last(n) : @items.last
+      end
+
+      # Get all elements
+      def to_a
+        @items.dup
+      end
+
+      # Convert to string (for text content)
+      def to_s
+        @items.join
+      end
+
+      # Current size
+      def size
+        @items.size
+      end
+
+      # Check if empty
+      def empty?
+        @items.empty?
+      end
+
+      # Clear all elements
+      def clear
+        @items.clear
+        @total_chars = 0
+        @truncated   = false
+        @chars_full  = false
+        self
+      end
+
+      # Iterate over elements
+      def each(&block)
+        @items.each(&block)
+      end
+
+      # kept for compatibility (called internally; public so subclasses can override)
+      def trim_if_needed
+        while @items.size > @max_size
+          removed = @items.shift
+          @total_chars -= removed.length if removed.is_a?(String)
+          @truncated = true
+        end
+      end
+
+      private def _push_one(element)
+        # --- chars budget check ---
+        if @chars_full
+          @truncated = true
+          return
+        end
+
+        item = element
+
+        # --- per-line truncation ---
+        if @max_line_chars && item.is_a?(String) && item.length > @max_line_chars
+          item = item[0, @max_line_chars]
+          # Preserve trailing newline if original had one
+          item += "\n" if element.end_with?("\n") && !item.end_with?("\n")
+          @truncated = true
+        end
+
+        # --- total chars check ---
+        if @max_chars && item.is_a?(String)
+          remaining = @max_chars - @total_chars
+          if remaining <= 0
+            @chars_full = true
+            @truncated  = true
+            return
+          end
+          if item.length > remaining
+            # If original line ends with \n we must preserve it, so reserve 1
+            # byte for it — this keeps total_chars strictly within max_chars.
+            needs_newline = element.is_a?(String) && element.end_with?("\n")
+            cut = needs_newline ? [remaining - 1, 0].max : remaining
+            item = item[0, cut]
+            item += "\n" if needs_newline && !item.end_with?("\n")
+            @chars_full = true
+            @truncated  = true
+          end
+        end
+
+        @items << item
+        @total_chars += item.length if item.is_a?(String)
+
+        trim_if_needed
+      end
+    end
+  end
+end

data/lib/octo/utils/logger.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module Octo
+  # Thread-safe daily-rotating file logger.
+  #
+  # Log files are written to ~/.octo/logger/octo-YYYY-MM-DD.log.
+  # At most 7 daily log files are kept; older ones are pruned automatically.
+  #
+  # Usage (anywhere in the codebase):
+  #   Octo::Logger.info("server started")
+  #   Octo::Logger.debug("tool result", tool: "shell", exit_code: 0)
+  #   Octo::Logger.warn("retry attempt", n: 3)
+  #   Octo::Logger.error("unhandled exception", error: e)
+  module Logger
+    LOG_DIR        = File.join(Dir.home, ".octo", "logger").freeze
+    MAX_LOG_FILES  = 7
+    MUTEX          = Mutex.new
+
+    # Level constants (numeric, for future filtering)
+    LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze
+
+    # Minimum level to echo to $stderr when console output is enabled.
+    # :debug → all; :info → info/warn/error; :warn → warn/error only
+    CONSOLE_MIN_LEVEL = :info
+
+    class << self
+      # Enable/disable echoing log lines to $stderr (in addition to the file).
+      # Call Octo::Logger.console = true from server startup to activate.
+      attr_writer :console
+
+      private def console?
+        @console ||= false
+      end
+
+      # Path of the log file currently being written to (today's file).
+      # File may not exist yet if no log has been emitted today — callers
+      # should check File.exist? before reading.
+      def current_log_file
+        log_file_path(Time.now)
+      end
+
+      # Log at DEBUG level.
+      def debug(message, **context)
+        write_log(:debug, message, context)
+      end
+
+      # Log at INFO level.
+      def info(message, **context)
+        write_log(:info, message, context)
+      end
+
+      # Log at WARN level.
+      def warn(message, **context)
+        write_log(:warn, message, context)
+      end
+
+      # Log at ERROR level.  Accepts an optional :error key that may be an
+      # Exception; its backtrace is appended automatically.
+      def error(message, **context)
+        write_log(:error, message, context)
+      end
+
+      private def write_log(level, message, context = {})
+        now  = Time.now
+        line = format_line(now, level, message, context)
+
+        MUTEX.synchronize do
+          ensure_log_dir
+          File.open(log_file_path(now), "a") { |f| f.puts(line) }
+          prune_old_logs
+          echo_to_console(level, line) if console?
+        end
+      rescue StandardError
+        # Never let logger errors crash the main process.
+        nil
+      end
+
+      private def echo_to_console(level, line)
+        return if LEVELS[level] < LEVELS[CONSOLE_MIN_LEVEL]
+        $stderr.puts(line)
+      rescue StandardError
+        nil
+      end
+
+      private def format_line(time, level, message, context)
+        timestamp = time.strftime("%Y-%m-%dT%H:%M:%S.%3N%z")
+        tag       = level.to_s.upcase.ljust(5)
+        base      = "[#{timestamp}] #{tag} #{message}"
+
+        if context.empty?
+          base
+        else
+          # Expand exception objects for :error key
+          if (err = context[:error]).is_a?(Exception)
+            context = context.merge(
+              error:     "#{err.class}: #{err.message}",
+              backtrace: (err.backtrace || []).first(10).join(" | ")
+            )
+          end
+          pairs = context.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")
+          "#{base} | #{pairs}"
+        end
+      end
+
+      private def log_file_path(time)
+        File.join(LOG_DIR, "octo-#{time.strftime('%Y-%m-%d')}.log")
+      end
+
+      private def ensure_log_dir
+        FileUtils.mkdir_p(LOG_DIR) unless Dir.exist?(LOG_DIR)
+      end
+
+      # Remove log files older than MAX_LOG_FILES days.
+      private def prune_old_logs
+        logs = Dir.glob(File.join(LOG_DIR, "octo-*.log")).sort
+        excess = logs.length - MAX_LOG_FILES
+        logs.first(excess).each { |f| File.delete(f) } if excess > 0
+      end
+    end
+  end
+end

data/lib/octo/utils/login_shell.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Octo
+  module Utils
+    # Spawn child processes in an environment that has the user's shell rc
+    # files sourced — so version managers (mise / rbenv / asdf / nvm) and
+    # custom PATH entries are active, even when the octo server itself
+    # was started by launchd / a desktop icon with a minimal PATH.
+    #
+    # ## Approach: manual `source` + `exec`
+    #
+    # Instead of using `$SHELL -l -i -c` (which prints rc banners, triggers
+    # job-control warnings in non-tty contexts, and may not even work as
+    # expected under launchd), we build an inline shell snippet:
+    #
+    #   { source ~/.zshenv; source ~/.zprofile; source ~/.zshrc; } 1>&2
+    #   exec <target-cmd>
+    #
+    # Then invoke it with plain `zsh -c <snippet>` (NO -l / -i flags).
+    #
+    # Why this wins:
+    #
+    # - `source ~/.zshrc` runs user's rc code including `eval "$(mise activate zsh)"`
+    #   which injects the correct PATH (so `node`/`ruby`/`gem` resolve).
+    # - `{ … } 1>&2` redirects ALL rc-time output (banners, welcome msgs,
+    #   mise warnings) to stderr, keeping target's stdout CLEAN — critical
+    #   for JSON-RPC stdio channels like chrome-devtools-mcp.
+    # - `exec` replaces the shell with the target process, so our pipe's
+    #   child is the target itself (pid / signals / waitpid all work).
+    # - No `-i`, so no "no job control in this shell" warnings.
+    # - No `-l` needed because we explicitly source what we need.
+    #
+    # ## Method: login_shell_command
+    #
+    # Build argv for `Open3.popen3` / `Process.spawn` that runs `command`
+    # with rc files pre-sourced. Returns argv, not a running process —
+    # caller picks the right Open3 method for their needs.
+    module LoginShell
+      # Build argv that runs `command` inside a shell with rc files sourced.
+      #
+      # @param command [String] shell-ready command (caller quotes user input).
+      # @return [Array<String>] argv for Open3.popen3 / Process.spawn.
+      def self.login_shell_command(command)
+        shell = ENV["SHELL"].to_s
+        shell = "/bin/bash" if shell.empty? || !File.executable?(shell)
+        name  = File.basename(shell)
+        name  = "bash" unless %w[zsh bash].include?(name)
+        shell = "/bin/bash" if name == "bash" && !File.executable?(shell)
+
+        rc_sources = rc_source_snippet(name)
+
+        # { rc_sources; } 1>&2 — send rc-time stdout to stderr so target's
+        # stdout is pristine. `exec` replaces the shell with target.
+        script = "{ #{rc_sources}; } 1>&2; exec #{command}"
+        [shell, "-c", script]
+      end
+
+      # Per-shell rc source chain. Order matters:
+      #   zsh:  .zshenv → .zprofile → .zshrc  (login + interactive equivalent)
+      #   bash: .profile → .bash_profile → .bashrc
+      def self.rc_source_snippet(shell_name)
+        files =
+          case shell_name
+          when "zsh"  then %w[.zshenv .zprofile .zshrc]
+          else             %w[.profile .bash_profile .bashrc]
+          end
+
+        files.map { |f| %([ -f "$HOME/#{f}" ] && . "$HOME/#{f}") }.join("; ")
+      end
+    end
+  end
+end