ace-git 0.18.0

data/lib/ace/git/atoms/status_formatter.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for formatting repository status as various output formats
+      # Extracted from Models::RepoStatus.to_markdown for ATOM purity
+      module StatusFormatter
+        class << self
+          # Format repository status as markdown
+          # @param status [Models::RepoStatus] Repository status
+          # @return [String] Markdown-formatted output
+          def to_markdown(status)
+            lines = []
+            lines << "# Repository Status"
+
+            # 1. Position section (includes git status -sb)
+            lines.concat(format_position_section(status))
+
+            # 2. Recent commits section
+            if status.has_recent_commits?
+              lines.concat(format_recent_commits_section(status.recent_commits))
+            end
+
+            # 3. Current PR section (for current branch)
+            if status.has_pr?
+              lines.concat(format_current_pr_section(status.pr_metadata))
+            end
+
+            # 4. PR Activity section (other PRs)
+            if status.has_pr_activity?
+              lines.concat(format_pr_activity_section(status.pr_activity))
+            end
+
+            lines.join("\n")
+          end
+
+          # Format position section with raw git status -sb output
+          # @param status [Models::RepoStatus] Repository status
+          # @return [Array<String>] Lines of markdown
+          def format_position_section(status)
+            lines = []
+            lines << ""
+
+            # Header with optional task pattern
+            header = "## Position"
+            header += " (task: #{status.task_pattern})" if status.has_task_pattern?
+            lines << header
+            lines << ""
+
+            # Raw git status -sb output
+            if status.has_git_status?
+              lines << status.git_status_sb
+            elsif status.branch
+              # Fallback if no git status available
+              lines << "Branch: #{status.branch}#{" (detached HEAD)" if status.detached?}"
+            end
+
+            lines
+          end
+
+          # Format recent commits section
+          # @param commits [Array<Hash>] Recent commits with :hash and :subject
+          # @return [Array<String>] Lines of markdown
+          def format_recent_commits_section(commits)
+            lines = []
+            lines << ""
+            lines << "## Recent Commits"
+            lines << ""
+            commits.each do |commit|
+              hash = commit[:hash] || commit["hash"]
+              subject = commit[:subject] || commit["subject"]
+              lines << "#{hash} #{subject}"
+            end
+            lines
+          end
+
+          # Format current PR section (highlighted for current branch)
+          # @param pr_metadata [Hash] PR metadata
+          # @return [Array<String>] Lines of markdown
+          def format_current_pr_section(pr_metadata)
+            lines = []
+            lines << ""
+            lines << "## Current PR"
+            lines << ""
+
+            # Main line: #85 [OPEN] Title
+            main_line = "##{pr_metadata["number"]}"
+            main_line += " [#{pr_metadata["state"]}]" if pr_metadata["state"]
+            main_line += " #{pr_metadata["title"]}" if pr_metadata["title"]
+            lines << main_line
+
+            # Details line: Target: main | Author: @username | Draft/Not draft
+            details = []
+            details << "Target: #{pr_metadata["baseRefName"]}" if pr_metadata["baseRefName"]
+            if pr_metadata["author"]
+              author = pr_metadata.dig("author", "login") || pr_metadata["author"]
+              details << "Author: @#{author}"
+            end
+            details << (pr_metadata["isDraft"] ? "Draft" : "Not draft") if pr_metadata.key?("isDraft")
+            lines << "  #{details.join(" | ")}" unless details.empty?
+
+            # URL line
+            lines << "  #{pr_metadata["url"]}" if pr_metadata["url"]
+
+            lines
+          end
+
+          # Format PR activity section
+          # @param pr_activity [Hash, nil] PR activity with :merged and :open arrays
+          #   Each PR in the arrays has string keys from JSON parsing: "number", "title", etc.
+          # @return [Array<String>] Lines of markdown
+          def format_pr_activity_section(pr_activity)
+            lines = []
+            lines << ""
+            lines << "## PR Activity"
+            lines << ""
+
+            # Handle nil pr_activity for defensive programming
+            return lines << "No recent PR activity" if pr_activity.nil?
+
+            # pr_activity uses symbol keys (from RepoStatusLoader)
+            # PR data within uses string keys (from JSON parsing)
+            merged = pr_activity[:merged] || []
+            open_prs = pr_activity[:open] || []
+
+            unless merged.empty?
+              lines << "Merged:"
+              merged.each do |pr|
+                title = pr["title"] || "(no title)"
+                merged_ago = format_merged_time_compact(pr["mergedAt"])
+                lines << "  ##{pr["number"]} #{title}#{merged_ago}"
+              end
+            end
+
+            unless open_prs.empty?
+              lines << "" unless merged.empty? # Add spacing between Merged and Open
+              lines << "Open:"
+              open_prs.each do |pr|
+                title = pr["title"] || "(no title)"
+                author = format_author(pr["author"])
+                lines << "  ##{pr["number"]} #{title}#{author}"
+              end
+            end
+
+            if merged.empty? && open_prs.empty?
+              lines << "No recent PR activity"
+            end
+
+            lines
+          end
+
+          private
+
+          # Format merged time as relative string (compact version)
+          # @param merged_at [String, nil] ISO8601 timestamp
+          # @return [String] Formatted string like " (1h ago)"
+          def format_merged_time_compact(merged_at)
+            return "" if merged_at.nil? || (merged_at.is_a?(String) && merged_at.empty?)
+
+            relative = TimeFormatter.relative_time(merged_at)
+            relative.empty? ? "" : " (#{relative})"
+          end
+
+          # Format author info
+          # @param author [Hash, String, nil] Author data
+          # @return [String] Formatted string like " (@username)"
+          def format_author(author)
+            return "" if author.nil?
+
+            login = author.is_a?(Hash) ? author["login"] : author.to_s
+            return "" if login.nil? || login.empty?
+
+            " (@#{login})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/task_pattern_extractor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Atoms
+      # Extracts task ID from branch name using configurable patterns
+      # Pure function - no I/O operations
+      #
+      # Consolidated from ace-review TaskAutoDetector
+      class TaskPatternExtractor
+        # Extract task ID from branch name using configurable patterns
+        # @param branch_name [String] e.g., "117-feature-name", "121.01-archive"
+        # @param patterns [Array<String>|nil] Optional regex patterns (uses default if nil)
+        # @return [String|nil] task ID or nil if not found
+        #
+        # Default pattern matches:
+        #   117-feature -> "117"
+        #   121.01-archive -> "121.01"
+        # Does not match:
+        #   main -> nil
+        #   feature-123 -> nil (number not at start)
+        def self.extract_from_branch(branch_name, patterns: nil)
+          return nil if branch_name.nil? || branch_name.empty?
+          return nil if branch_name == "HEAD" # Detached HEAD state
+
+          # Use provided patterns or default pattern
+          patterns ||= ['^(\d+(?:\.\d+)?)-']
+
+          patterns.each do |pattern|
+            regex = Regexp.new(pattern)
+            match = branch_name.match(regex)
+            return match[1] if match && match[1]
+          rescue RegexpError => e
+            warn "Warning: Invalid task pattern '#{pattern}': #{e.message}"
+            next
+          end
+
+          nil
+        end
+
+        # Extract task ID using default patterns
+        # @param branch_name [String] Branch name to extract from
+        # @return [String|nil] Task ID or nil
+        def self.extract(branch_name)
+          extract_from_branch(branch_name)
+        end
+
+        # Check if branch name contains a task pattern
+        # @param branch_name [String] Branch name to check
+        # @return [Boolean] True if branch contains task pattern
+        def self.has_task_pattern?(branch_name)
+          !extract(branch_name).nil?
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/atoms/time_formatter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Ace
+  module Git
+    module Atoms
+      # Pure functions for formatting timestamps as relative time strings
+      # Examples: "2h ago", "1d ago", "3w ago"
+      module TimeFormatter
+        # Time constants for format_duration calculations
+        SECONDS_PER_MINUTE = 60
+        MINUTES_PER_HOUR = 60
+        HOURS_PER_DAY = 24
+        DAYS_PER_WEEK = 7
+        DAYS_PER_MONTH = 30  # Simplified (actual avg ~30.44)
+        DAYS_PER_YEAR = 365
+        MONTHS_PER_YEAR = 12
+
+        class << self
+          # Convert an ISO8601 timestamp to relative time
+          # @param timestamp [String, Time] ISO8601 timestamp or Time object
+          # @param reference_time [Time] Time to compare against (default: Time.now)
+          # @return [String] Relative time string like "2h ago", "1d ago", or empty for future times
+          def relative_time(timestamp, reference_time: Time.now)
+            return "" if timestamp.nil? || (timestamp.is_a?(String) && timestamp.empty?)
+
+            time = parse_timestamp(timestamp)
+            return "" if time.nil?
+
+            seconds_ago = (reference_time - time).to_i
+            # Don't format future times (negative duration)
+            return "" if seconds_ago < 0
+
+            format_duration(seconds_ago)
+          end
+
+          private
+
+          # Parse timestamp to Time object
+          # @param timestamp [String, Time] Timestamp to parse
+          # @return [Time, nil] Parsed time or nil
+          def parse_timestamp(timestamp)
+            return timestamp if timestamp.is_a?(Time)
+
+            Time.parse(timestamp)
+          rescue ArgumentError, TypeError
+            nil
+          end
+
+          # Format duration in seconds as human-readable string
+          # @param seconds [Integer] Duration in seconds
+          # @return [String] Formatted duration
+          def format_duration(seconds)
+            return "just now" if seconds < SECONDS_PER_MINUTE
+
+            minutes = seconds / SECONDS_PER_MINUTE
+            return "#{minutes}m ago" if minutes < MINUTES_PER_HOUR
+
+            hours = minutes / MINUTES_PER_HOUR
+            return "#{hours}h ago" if hours < HOURS_PER_DAY
+
+            days = hours / HOURS_PER_DAY
+            return "#{days}d ago" if days < DAYS_PER_WEEK
+
+            weeks = days / DAYS_PER_WEEK
+            return "#{weeks}w ago" if days < DAYS_PER_MONTH
+
+            # Use months until we hit a full year (365 days)
+            # This avoids "0y ago" for 360-364 day intervals
+            # Note: Using 30 days/month is a simplification (actual avg is ~30.44)
+            # but is acceptable for relative time display purposes
+            # Use floor with minimum 1 to avoid "0mo ago" for 30-day intervals
+            months = [(days * MONTHS_PER_YEAR.to_f / DAYS_PER_YEAR).floor, 1].max
+            return "#{months}mo ago" if days < DAYS_PER_YEAR
+
+            years = days / DAYS_PER_YEAR
+            "#{years}y ago"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/cli/commands/branch.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+require "ace/support/cli"
+
+module Ace
+  module Git
+    module CLI
+      module Commands
+        # ace-support-cli command for showing branch information
+        class Branch < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Show current branch information"
+
+          option :format, type: :string, aliases: ["f"], default: "text",
+            desc: "Output format: text, json"
+
+          # Standard options
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          def call(**options)
+            # Get branch info
+            branch_info = Molecules::BranchReader.full_info
+
+            if branch_info[:error]
+              raise Ace::Support::Cli::Error.new(branch_info[:error])
+            end
+
+            # Output based on format
+            case options[:format]
+            when "json"
+              puts JSON.pretty_generate(branch_info)
+            else
+              output_text(branch_info)
+            end
+          rescue Ace::Git::Error => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          end
+
+          private
+
+          def output_text(info)
+            output = info[:name]
+
+            if info[:detached]
+              output += " (detached HEAD)"
+            elsif info[:tracking]
+              output += " (tracking: #{info[:tracking]}"
+              output += ", #{info[:status_description]}" unless info[:up_to_date]
+              output += ")"
+            end
+
+            puts output
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/cli/commands/diff.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+require "yaml"
+require "ace/support/cli"
+
+module Ace
+  module Git
+    module CLI
+      module Commands
+        # ace-support-cli command for generating diffs
+        # Migrated from ace-git-diff
+        class Diff < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Generate git diff with filtering (default command)"
+
+          argument :range, required: false, desc: "Git range (e.g., HEAD~5..HEAD, origin/main..HEAD)"
+
+          option :format, type: :string, aliases: ["f"], default: "diff",
+            desc: "Output format: diff, summary, grouped-stats"
+          option :since, type: :string, aliases: ["s"],
+            desc: "Changes since date/duration (e.g., '7d', '1 week ago')"
+          option :paths, type: :array, aliases: ["p"],
+            desc: "Include only these glob patterns"
+          option :exclude, type: :array, aliases: ["e"],
+            desc: "Exclude these glob patterns"
+          option :output, type: :string, aliases: ["o"],
+            desc: "Write diff to file instead of stdout"
+          option :config, type: :string, aliases: ["c"],
+            desc: "Load config from specific file"
+          option :raw, type: :boolean, default: false,
+            desc: "Raw unfiltered output (no exclusions)"
+
+          # Standard options
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
+          option :debug, type: :boolean, aliases: %w[-d], desc: "Show debug output"
+
+          def call(range: nil, **options)
+            # Verify we're in a git repository
+            unless Atoms::CommandExecutor.in_git_repo?
+              raise Ace::Git::GitError, "Not a git repository (or any of the parent directories)"
+            end
+
+            # Build options hash, including any custom config file
+            diff_options = build_options(range, options)
+
+            # Generate diff
+            result = if options[:raw]
+              Organisms::DiffOrchestrator.raw(diff_options)
+            else
+              Organisms::DiffOrchestrator.generate(diff_options)
+            end
+
+            # Output result
+            output_result(result, options)
+
+            # Return success
+            0
+          rescue Ace::Git::Error => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          end
+
+          private
+
+          def build_options(range, cli_options)
+            options = {}
+
+            # Load custom config file if specified
+            if cli_options[:config]
+              custom_config = load_config_file(cli_options[:config])
+              options.merge!(custom_config)
+            end
+
+            # Add range if specified
+            options[:ranges] = [range] if range
+
+            # Add since if specified
+            options[:since] = cli_options[:since] if cli_options[:since]
+
+            # Add path filters
+            options[:paths] = cli_options[:paths] if cli_options[:paths]
+
+            # Add exclude patterns (overrides config if specified)
+            options[:exclude_patterns] = cli_options[:exclude] if cli_options[:exclude]
+
+            # Add format
+            options[:format] = normalized_format(cli_options[:format])
+
+            options
+          end
+
+          # Load configuration from a YAML file
+          # Handles both flat config and git:-rooted config (per .ace/git/config.yml format)
+          # @param config_path [String] Path to config file
+          # @return [Hash] Configuration hash
+          def load_config_file(config_path)
+            unless file_exist?(config_path)
+              raise Ace::Git::ConfigError, "Config file not found: #{config_path}"
+            end
+
+            config = yaml_safe_load(file_read(config_path))
+            config ||= {}
+
+            # Handle git:-rooted config files (standard .ace/git/config.yml format)
+            # Extract git section first, then extract diff config from it
+            git_config = config["git"] || config[:git] || config
+            Molecules::ConfigLoader.extract_diff_config(git_config)
+          rescue Psych::SyntaxError => e
+            raise Ace::Git::ConfigError, "Invalid YAML in config file: #{e.message}"
+          end
+
+          def output_result(result, options)
+            content = format_content(result, options)
+
+            # Write to file or stdout
+            if options[:output]
+              write_to_file(content, options[:output])
+            else
+              puts content
+            end
+          end
+
+          def format_content(result, options)
+            if result.empty?
+              return "(no changes)"
+            end
+
+            case normalized_format(options[:format])
+            when :summary
+              format_summary(result)
+            when :grouped_stats
+              format_grouped_stats(result, output_path: options[:output])
+            else
+              result.content
+            end
+          end
+
+          def write_to_file(content, output_path)
+            # Validate path to prevent directory traversal attacks
+            validate_output_path(output_path)
+
+            # Create parent directories if needed
+            FileUtils.mkdir_p(File.dirname(output_path)) unless File.dirname(output_path) == "."
+
+            # Write content to file
+            File.write(output_path, content)
+
+            # Output confirmation to stderr so it doesn't interfere with piping
+            warn "Diff written to: #{output_path}"
+          end
+
+          # Validate output path to prevent directory traversal attacks
+          # Strictly restricts output paths to current working directory or temp directory
+          # Uses File.realpath (when available) to resolve symlinks and normalize paths
+          # @param path [String] Path to validate
+          # @raise [Ace::Git::ConfigError] If path contains traversal sequences or escapes allowed directories
+          def validate_output_path(path)
+            # Check for null bytes (security)
+            if path.include?("\0")
+              raise Ace::Git::ConfigError, "Invalid output path: null bytes not allowed"
+            end
+
+            # Explicitly reject path traversal sequences
+            if path.include?("..")
+              raise Ace::Git::ConfigError, "Invalid output path: path traversal not allowed"
+            end
+
+            # Resolve the actual path - use realpath for existing paths to resolve symlinks,
+            # otherwise use expand_path for new paths (file doesn't exist yet)
+            expanded = File.expand_path(path)
+
+            # Get allowed directories, resolving symlinks where possible
+            cwd = resolve_real_path(Dir.pwd)
+            tmpdir = resolve_real_path(Dir.tmpdir)
+
+            # Strictly enforce that path is within cwd or tmpdir (no exceptions)
+            unless expanded.start_with?("#{cwd}/") || expanded == cwd ||
+                expanded.start_with?("#{tmpdir}/") || expanded == tmpdir
+              raise Ace::Git::ConfigError,
+                "Invalid output path: must be within working directory or temp directory"
+            end
+          end
+
+          # Resolve path to real path (resolving symlinks), falling back to expand_path
+          # @param path [String] Path to resolve
+          # @return [String] Resolved path
+          def resolve_real_path(path)
+            File.realpath(path)
+          rescue Errno::ENOENT
+            File.expand_path(path)
+          end
+
+          def format_summary(result)
+            summary = []
+            summary << "# Diff Summary"
+            summary << ""
+            summary << result.summary
+            summary << ""
+
+            if result.files.any?
+              summary << "## Files Changed"
+              result.files.each do |file|
+                summary << "- #{file}"
+              end
+              summary << ""
+            end
+
+            summary.join("\n")
+          end
+
+          def format_grouped_stats(result, output_path: nil)
+            grouped_data = result.metadata[:grouped_stats] || result.metadata["grouped_stats"]
+            return result.content unless grouped_data
+
+            collapse_above = grouped_data[:collapse_above] || grouped_data["collapse_above"] || 5
+            markdown = output_path && File.extname(output_path) == ".md"
+            Atoms::GroupedStatsFormatter.format(grouped_data, markdown: markdown, collapse_above: collapse_above)
+          end
+
+          def normalized_format(value)
+            return :diff if value.nil?
+
+            value.to_s.tr("-", "_").to_sym
+          end
+
+          protected
+
+          # Protected methods for external dependency access (testability pattern)
+          # See guide://testable-code-patterns for rationale
+
+          # Check if file exists (protected for test stubbing)
+          def file_exist?(path)
+            File.exist?(path)
+          end
+
+          # Read file content (protected for test stubbing)
+          def file_read(path)
+            File.read(path)
+          end
+
+          # Parse YAML safely (protected for test stubbing)
+          def yaml_safe_load(content)
+            YAML.safe_load(content, permitted_classes: [Symbol])
+          end
+        end
+      end
+    end
+  end
+end