ace-git 0.18.0

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+require "ace/support/cli"
+
+module Ace
+  module Git
+    module CLI
+      module Commands
+        # ace-support-cli command for showing PR information
+        class Pr < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Show PR information"
+
+          argument :number, required: false, desc: "PR number (auto-detected if not provided)"
+
+          option :format, type: :string, aliases: ["f"], default: "markdown",
+            desc: "Output format: markdown, json"
+          option :with_diff, type: :boolean, default: false,
+            desc: "Include PR diff in output"
+
+          # 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(number: nil, **options)
+            # Check if gh is installed
+            unless Molecules::PrMetadataFetcher.gh_installed?
+              raise Ace::Support::Cli::Error.new("GitHub CLI (gh) not installed. Install with: brew install gh")
+            end
+
+            # Determine PR identifier
+            identifier = if number
+              number.to_s
+            else
+              # Try to find PR for current branch
+              found = Molecules::PrMetadataFetcher.find_pr_for_branch
+              unless found
+                raise Ace::Support::Cli::Error.new("No PR found for current branch. Specify a PR number.")
+              end
+              found
+            end
+
+            # Fetch PR data
+            result = if options[:with_diff]
+              Molecules::PrMetadataFetcher.fetch_pr(identifier)
+            else
+              Molecules::PrMetadataFetcher.fetch_metadata(identifier)
+            end
+
+            unless result[:success]
+              raise Ace::Support::Cli::Error.new(result[:error])
+            end
+
+            # Output based on format
+            case options[:format]
+            when "json"
+              output_data = {metadata: result[:metadata]}
+              output_data[:diff] = result[:diff] if options[:with_diff]
+              puts JSON.pretty_generate(output_data)
+            else
+              output_markdown(result[:metadata], result[:diff], options)
+            end
+          rescue Ace::Git::Error => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          rescue ArgumentError => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          end
+
+          private
+
+          def output_markdown(metadata, diff, options)
+            lines = []
+
+            # Header line: # PR #82: Title... [OPEN]
+            header = "# PR ##{metadata["number"]}"
+            header += ": #{metadata["title"]}" if metadata["title"]
+            header += " [#{metadata["state"]}]" if metadata["state"]
+            lines << header
+
+            # Branch line: Branch: source → target | Draft: No
+            branch_parts = []
+            if metadata["headRefName"] && metadata["baseRefName"]
+              branch_parts << "Branch: #{metadata["headRefName"]} → #{metadata["baseRefName"]}"
+            elsif metadata["headRefName"]
+              branch_parts << "Branch: #{metadata["headRefName"]}"
+            elsif metadata["baseRefName"]
+              branch_parts << "Target: #{metadata["baseRefName"]}"
+            end
+            branch_parts << "Draft: #{metadata["isDraft"] ? "Yes" : "No"}" if metadata.key?("isDraft")
+            lines << branch_parts.join(" | ") unless branch_parts.empty?
+
+            # Author line
+            if metadata["author"]
+              author = metadata["author"].is_a?(Hash) ? metadata["author"]["login"] : metadata["author"]
+              lines << "Author: #{author}"
+            end
+
+            # URL line
+            lines << "URL: #{metadata["url"]}" if metadata["url"]
+
+            if options[:with_diff] && diff
+              lines << ""
+              lines << "## Diff"
+              lines << ""
+              lines << "```diff"
+              lines << diff
+              lines << "```"
+            end
+
+            puts lines.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "json"
+require "ace/support/cli"
+
+module Ace
+  module Git
+    module CLI
+      module Commands
+        # ace-support-cli command for showing repository status
+        class Status < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc "Show repository context (branch, PR, activity)"
+
+          option :format, type: :string, aliases: ["f"], default: "markdown",
+            desc: "Output format: markdown, json"
+          option :with_diff, type: :boolean, default: false,
+            desc: "Include PR diff in output"
+          option :no_pr, type: :boolean, default: false, aliases: ["n"],
+            desc: "Skip all PR lookups (faster, no network)"
+          option :commits, type: :integer, aliases: ["c"],
+            desc: "Number of recent commits to show (0 to disable, default: config)"
+
+          # 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)
+            # Determine PR settings based on --no-pr flag
+            skip_pr = options[:no_pr]
+            commits_limit = options[:commits] || Ace::Git.commits_limit
+
+            # Load status
+            status_options = {
+              include_pr: !skip_pr,
+              include_pr_activity: !skip_pr,
+              include_commits: commits_limit > 0,
+              commits_limit: commits_limit,
+              timeout: Ace::Git.network_timeout
+            }
+
+            status = Organisms::RepoStatusLoader.load(status_options)
+
+            # Check for errors
+            if status.branch.nil? && status.repository_type == :not_git
+              raise Ace::Support::Cli::Error.new("Not in a git repository")
+            end
+
+            # Output based on format
+            case options[:format]
+            when "json"
+              puts JSON.pretty_generate(status.to_h)
+            else
+              puts status.to_markdown
+            end
+
+            # Include diff if requested
+            if options[:with_diff] && status.has_pr?
+              begin
+                diff_result = Molecules::PrMetadataFetcher.fetch_diff(
+                  status.pr_metadata["number"].to_s
+                )
+                if diff_result[:success]
+                  puts ""
+                  puts "## PR Diff"
+                  puts ""
+                  puts "```diff"
+                  puts diff_result[:diff]
+                  puts "```"
+                end
+              rescue Ace::Git::Error
+                # Silently skip diff if it fails
+              end
+            end
+          rescue Ace::Git::Error => e
+            raise Ace::Support::Cli::Error.new(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/cli.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "../git"
+require_relative "cli/commands/diff"
+require_relative "cli/commands/status"
+require_relative "cli/commands/branch"
+require_relative "cli/commands/pr"
+
+module Ace
+  module Git
+    # ace-support-cli command registry for ace-git.
+    module CLI
+      extend Ace::Support::Cli::RegistryDsl
+
+      # Entry point for CLI invocation (used by tests via cli_helpers)
+      #
+      # Mirrors the exe's normalized_args logic so in-process tests
+      # can exercise range-pattern routing.
+      #
+      # @param args [Array<String>] Command-line arguments
+      def self.start(args)
+        Ace::Support::Cli::Runner.new(self).call(args: normalized_args(args))
+      end
+
+      # Normalize arguments to handle empty args and git range patterns.
+      # Extracted from exe/ace-git for in-process testability.
+      def self.normalized_args(argv)
+        return ["--help"] if argv.empty?
+        return ["diff"] + argv if git_range_pattern?(argv.first)
+
+        argv
+      end
+
+      def self.git_range_pattern?(arg)
+        return false if arg.nil?
+
+        return true if arg.match?(/\.\.\.?/) # Range operators: .. or ...
+        return true if arg.match?(/[~^]\d*/) # Ref modifiers: ~, ~2, ^, ^2
+        return true if arg == "HEAD"         # Exact HEAD match
+        return true if arg.match?(/@\{/)     # Reflog: @{1}, @{yesterday}
+
+        false
+      end
+
+      private_class_method :git_range_pattern?
+
+      PROGRAM_NAME = "ace-git"
+
+      REGISTERED_COMMANDS = [
+        ["diff", "Show filtered git diff output"],
+        ["status", "Show repository status and PR context"],
+        ["branch", "Show current branch information"],
+        ["pr", "Show pull request information"]
+      ].freeze
+
+      HELP_EXAMPLES = [
+        "ace-git diff --since 7d           # Changes from last week",
+        "ace-git diff -p 'lib/**' -f summary  # Filtered summary",
+        "ace-git status --no-pr            # Quick status, skip network"
+      ].freeze
+
+      register "diff", Commands::Diff.new
+      register "status", Commands::Status.new
+      register "branch", Commands::Branch.new
+      register "pr", Commands::Pr.new
+
+      version_cmd = Ace::Support::Cli::VersionCommand.build(
+        gem_name: "ace-git",
+        version: Ace::Git::VERSION
+      )
+      register "version", version_cmd
+      register "--version", version_cmd
+
+      help_cmd = Ace::Support::Cli::HelpCommand.build(
+        program_name: PROGRAM_NAME,
+        version: Ace::Git::VERSION,
+        commands: REGISTERED_COMMANDS,
+        examples: HELP_EXAMPLES
+      )
+      register "help", help_cmd
+      register "--help", help_cmd
+      register "-h", help_cmd
+    end
+  end
+end

data/lib/ace/git/models/diff_config.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Models
+      # Data structure representing diff configuration
+      # Migrated from ace-git-diff
+      class DiffConfig
+        attr_reader :exclude_patterns, :exclude_whitespace, :exclude_renames,
+          :exclude_moves, :max_lines, :ranges, :paths, :since, :format, :timeout,
+          :grouped_stats_layers, :grouped_stats_collapse_above,
+          :grouped_stats_show_full_tree, :grouped_stats_dotfile_groups
+
+        # @param exclude_patterns [Array<String>] Glob patterns to exclude
+        # @param exclude_whitespace [Boolean] Whether to exclude whitespace changes
+        # @param exclude_renames [Boolean] Whether to exclude renames
+        # @param exclude_moves [Boolean] Whether to exclude moves
+        # @param max_lines [Integer] Maximum lines in diff output
+        # @param ranges [Array<String>] Git ranges to diff (e.g., ["origin/main...HEAD"])
+        # @param paths [Array<String>] Path patterns to include
+        # @param since [String] Date or commit to diff from
+        # @param format [Symbol] Output format (:diff or :summary)
+        # @param timeout [Integer] Command timeout in seconds (default from config)
+        # @param grouped_stats_layers [Array<String>] Layer order for grouped-stats output
+        # @param grouped_stats_collapse_above [Integer] Markdown collapse threshold
+        # @param grouped_stats_show_full_tree [String] Tree rendering mode
+        # @param grouped_stats_dotfile_groups [Array<String>] Dot directories to prioritize
+        def initialize(
+          exclude_patterns: [],
+          exclude_whitespace: true,
+          exclude_renames: false,
+          exclude_moves: false,
+          max_lines: 10_000,
+          ranges: [],
+          paths: [],
+          since: nil,
+          format: :diff,
+          timeout: Ace::Git.git_timeout,
+          grouped_stats_layers: %w[lib test handbook],
+          grouped_stats_collapse_above: 5,
+          grouped_stats_show_full_tree: "collapsible",
+          grouped_stats_dotfile_groups: %w[.ace-taskflow .ace]
+        )
+          @exclude_patterns = Array(exclude_patterns)
+          @exclude_whitespace = exclude_whitespace
+          @exclude_renames = exclude_renames
+          @exclude_moves = exclude_moves
+          @max_lines = max_lines
+          @ranges = Array(ranges)
+          @paths = Array(paths)
+          @since = since
+          @format = format&.to_sym || :diff
+          @timeout = timeout || Ace::Git.git_timeout
+          @grouped_stats_layers = Array(grouped_stats_layers).map(&:to_s)
+          @grouped_stats_collapse_above = grouped_stats_collapse_above.to_i
+          @grouped_stats_show_full_tree = grouped_stats_show_full_tree.to_s
+          @grouped_stats_dotfile_groups = Array(grouped_stats_dotfile_groups).map(&:to_s)
+        end
+
+        # Check if diff should exclude whitespace changes
+        # @return [Boolean] True if whitespace should be excluded
+        def exclude_whitespace?
+          @exclude_whitespace
+        end
+
+        # Check if diff should exclude renames
+        # @return [Boolean] True if renames should be excluded
+        def exclude_renames?
+          @exclude_renames
+        end
+
+        # Check if diff should exclude moves
+        # @return [Boolean] True if moves should be excluded
+        def exclude_moves?
+          @exclude_moves
+        end
+
+        # Get git diff command flags based on configuration
+        # @return [Array<String>] Command flags
+        def git_flags
+          flags = []
+          flags << "-w" if exclude_whitespace?
+          # Use --diff-filter to exclude renames (R) and optionally moves
+          # This is more explicit and avoids redundant flags
+          # ACDMTUXB includes: Added, Copied, Deleted, Modified, Type, Unmerged, Unknown, Broken
+          # When excluding moves, we also disable copy detection (C) as moves are detected as copy+delete
+          if exclude_renames? && exclude_moves?
+            # Exclude both renames (R) and copies (C) which covers moves
+            flags << "--diff-filter=ADMTUXB"
+            flags << "-M0" # Disable rename detection entirely
+          elsif exclude_renames?
+            flags << "--diff-filter=ACDMTUXB"
+          elsif exclude_moves?
+            # Moves appear as rename with 100% similarity, disable high-similarity renames
+            flags << "-M0" # Disable rename detection (moves are renames at 100% similarity)
+          end
+          flags
+        end
+
+        # Convert to hash representation
+        # @return [Hash] Hash representation of the config
+        def to_h
+          {
+            exclude_patterns: exclude_patterns,
+            exclude_whitespace: exclude_whitespace?,
+            exclude_renames: exclude_renames?,
+            exclude_moves: exclude_moves?,
+            max_lines: max_lines,
+            ranges: ranges,
+            paths: paths,
+            since: since,
+            format: format,
+            timeout: timeout,
+            grouped_stats: {
+              layers: grouped_stats_layers,
+              collapse_above: grouped_stats_collapse_above,
+              show_full_tree: grouped_stats_show_full_tree,
+              dotfile_groups: grouped_stats_dotfile_groups
+            }
+          }
+        end
+
+        # Known configuration keys
+        KNOWN_KEYS = %w[
+          exclude_patterns exclude_whitespace exclude_renames exclude_moves
+          max_lines ranges paths since format timeout grouped_stats
+        ].freeze
+
+        # Create DiffConfig from hash (e.g., from YAML config)
+        # Warns on unknown keys to help users catch typos
+        # @param hash [Hash] Configuration hash
+        # @return [DiffConfig] New DiffConfig instance
+        def self.from_hash(hash)
+          return new if hash.nil? || hash.empty?
+
+          # Warn about unknown keys to help catch typos
+          warn_unknown_keys(hash)
+
+          grouped_stats = hash["grouped_stats"] || hash[:grouped_stats] || {}
+
+          new(
+            exclude_patterns: hash["exclude_patterns"] || hash[:exclude_patterns] || [],
+            exclude_whitespace: hash.fetch("exclude_whitespace", hash.fetch(:exclude_whitespace, true)),
+            exclude_renames: hash.fetch("exclude_renames", hash.fetch(:exclude_renames, false)),
+            exclude_moves: hash.fetch("exclude_moves", hash.fetch(:exclude_moves, false)),
+            max_lines: hash.fetch("max_lines", hash.fetch(:max_lines, 10_000)),
+            ranges: hash["ranges"] || hash[:ranges] || [],
+            paths: hash["paths"] || hash[:paths] || [],
+            since: hash["since"] || hash[:since],
+            format: hash["format"] || hash[:format] || :diff,
+            timeout: hash.fetch("timeout", hash.fetch(:timeout, Ace::Git.git_timeout)),
+            grouped_stats_layers: grouped_stats["layers"] || grouped_stats[:layers] || %w[lib test handbook],
+            grouped_stats_collapse_above: grouped_stats.fetch("collapse_above", grouped_stats.fetch(:collapse_above, 5)),
+            grouped_stats_show_full_tree: grouped_stats["show_full_tree"] || grouped_stats[:show_full_tree] || "collapsible",
+            grouped_stats_dotfile_groups: grouped_stats["dotfile_groups"] || grouped_stats[:dotfile_groups] || %w[.ace-taskflow .ace]
+          )
+        end
+
+        # Warn about unknown configuration keys
+        # @param hash [Hash] Configuration hash
+        def self.warn_unknown_keys(hash)
+          return if hash.nil? || hash.empty?
+
+          hash.each_key do |key|
+            key_str = key.to_s
+            next if KNOWN_KEYS.include?(key_str)
+            # Skip nested sections that may be passed through
+            next if %w[diff rebase pr squash default_branch remote verbose].include?(key_str)
+
+            warn "[ace-git] Unknown config key '#{key_str}' in DiffConfig - did you mean one of: #{KNOWN_KEYS.join(", ")}?"
+          end
+        end
+
+        # Merge with another config (other takes precedence - complete override)
+        # @param other [DiffConfig, Hash] Other config to merge
+        # @return [DiffConfig] New merged DiffConfig
+        def merge(other)
+          other_hash = other.is_a?(DiffConfig) ? other.to_h : other
+
+          self.class.from_hash(to_h.merge(other_hash))
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/models/diff_result.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Models
+      # Data structure representing the result of a diff operation
+      # Migrated from ace-git-diff
+      class DiffResult
+        attr_reader :content, :stats, :files, :metadata, :filtered
+
+        # @param content [String] The diff content
+        # @param stats [Hash] Statistics about the diff (additions, deletions, files)
+        # @param files [Array<String>] List of files in the diff
+        # @param metadata [Hash] Additional metadata (range, since, options, etc)
+        # @param filtered [Boolean] Whether the diff has been filtered
+        def initialize(content:, stats:, files:, metadata: {}, filtered: false)
+          @content = content
+          @stats = stats
+          @files = files
+          @metadata = metadata
+          @filtered = filtered
+        end
+
+        # Check if the diff is empty
+        # @return [Boolean] True if diff has no content
+        def empty?
+          content.nil? || content.strip.empty?
+        end
+
+        # Check if the diff has changes
+        # @return [Boolean] True if diff contains additions or deletions
+        def has_changes?
+          stats[:total_changes].to_i > 0
+        end
+
+        # Get the number of lines in the diff
+        # @return [Integer] Line count
+        def line_count
+          stats[:line_count] || content&.count("\n")&.+(1) || 0
+        end
+
+        # Get human-readable summary
+        # @return [String] Summary string
+        def summary
+          "#{files.length} files, +#{stats[:additions]} -#{stats[:deletions]}"
+        end
+
+        # Convert to hash representation
+        # @return [Hash] Hash representation of the diff result
+        def to_h
+          {
+            content: content,
+            stats: stats,
+            files: files,
+            metadata: metadata,
+            filtered: filtered,
+            empty: empty?,
+            has_changes: has_changes?,
+            line_count: line_count,
+            summary: summary
+          }
+        end
+
+        # Create a DiffResult from parsed diff data
+        # @param parsed_data [Hash] Parsed diff data from DiffParser
+        # @param metadata [Hash] Additional metadata
+        # @param filtered [Boolean] Whether the diff was filtered
+        # @return [DiffResult] New DiffResult instance
+        def self.from_parsed(parsed_data, metadata: {}, filtered: false)
+          new(
+            content: parsed_data[:content],
+            stats: parsed_data[:stats].merge(line_count: parsed_data[:line_count]),
+            files: parsed_data[:files],
+            metadata: metadata,
+            filtered: filtered
+          )
+        end
+
+        # Create an empty DiffResult
+        # @param metadata [Hash] Optional metadata
+        # @return [DiffResult] Empty DiffResult instance
+        def self.empty(metadata: {})
+          new(
+            content: "",
+            stats: {additions: 0, deletions: 0, files: 0, total_changes: 0, line_count: 0},
+            files: [],
+            metadata: metadata,
+            filtered: false
+          )
+        end
+      end
+    end
+  end
+end