ace-review 0.49.0

data/lib/ace/review/cli/commands/feedback/session_discovery.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "ace/support/fs"
+
+module Ace
+  module Review
+    module CLI
+      module Commands
+        module FeedbackSubcommands
+          # Shared session discovery logic for feedback CLI commands
+          #
+          # This module provides common methods for resolving review sessions
+          # from options or finding the latest session in the cache.
+          module SessionDiscovery
+            # Resolve feedback path from session context
+            #
+            # Priority:
+            # 1. --session flag (explicit session directory)
+            # 2. Most recent session in cache directory (default)
+            #
+            # @param options [Hash] Command options
+            # @return [String, nil] Base path for feedback directory
+            def resolve_feedback_path(options)
+              # Check explicit session flag first
+              if options[:session]
+                session_path = File.expand_path(options[:session])
+                return session_path if Dir.exist?(session_path)
+
+                raise Ace::Support::Cli::Error.new("Session not found: #{session_path}")
+              end
+
+              # Default: use most recent session
+              find_latest_session
+            end
+
+            # Resolve session directory from options
+            #
+            # @param options [Hash] Command options
+            # @return [String, nil] Session directory path
+            def resolve_session_dir(options)
+              resolve_feedback_path(options)
+            end
+
+            # Find the most recent session directory
+            #
+            # @return [String, nil] Path to latest session or nil
+            def find_latest_session
+              sessions = find_all_sessions
+              sessions.first
+            end
+
+            # Find all session directories
+            #
+            # @return [Array<String>] All session directory paths, sorted by mtime (newest first)
+            def find_all_sessions
+              root = Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
+              cache_dir = File.join(root, ".ace-local", "review", "sessions")
+              cache_dir = File.join(root, ".cache", "ace-review", "sessions") unless Dir.exist?(cache_dir)
+              return [] unless Dir.exist?(cache_dir)
+
+              Dir.glob(File.join(cache_dir, "review-*"))
+                .select { |p| File.directory?(p) }
+                .sort_by { |p| -File.mtime(p).to_i }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/cli/commands/feedback/show.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "session_discovery"
+
+module Ace
+  module Review
+    module CLI
+      module Commands
+        module FeedbackSubcommands
+          # ace-support-cli Command class for feedback show
+          #
+          # Displays detailed information about a feedback item.
+          class Show < Ace::Support::Cli::Command
+            include Ace::Support::Cli::Base
+            include SessionDiscovery
+
+            desc <<~DESC.strip
+              Show detailed information about a feedback item
+
+              Displays full content including finding, context, research notes,
+              and resolution (if any). Supports partial ID matching with minimum
+              3 characters.
+            DESC
+
+            example [
+              "abc123                     # Show by full ID (latest session)",
+              "abc                        # Show by partial ID (min 3 chars)",
+              "abc123 --session .ace-local/review/sessions/review-xyz  # From specific session"
+            ]
+
+            argument :id, required: true, desc: "Feedback ID (minimum 3 characters for partial match)"
+            option :session, type: :string, desc: "Session directory containing feedback"
+
+            # 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(id:, **options)
+              # Validate ID length
+              if id.length < 3
+                raise Ace::Support::Cli::Error.new("ID must be at least 3 characters for matching.")
+              end
+
+              # Resolve feedback path from session context
+              base_path = resolve_feedback_path(options)
+
+              unless base_path
+                raise Ace::Support::Cli::Error.new("No session found. Run a review first or use --session to specify path.")
+              end
+
+              debug_log("Feedback base path: #{base_path}", options)
+
+              # Find item by ID (supports partial matching)
+              item = find_item_by_id(base_path, id, include_archived: true)
+
+              unless item
+                raise Ace::Support::Cli::Error.new("Feedback item not found: #{id}")
+              end
+
+              display_item(item)
+            end
+
+            private
+
+            # Find item by ID with partial matching
+            #
+            # @param base_path [String] Base path for feedback directory
+            # @param id [String] Full or partial ID
+            # @param include_archived [Boolean] Whether to search archived items
+            # @return [Models::FeedbackItem, nil] Found item or nil
+            def find_item_by_id(base_path, id, include_archived: false)
+              manager = Organisms::FeedbackManager.new
+              dir_manager = manager.directory_manager
+              file_reader = manager.file_reader
+
+              # Search in active directory
+              feedback_dir = dir_manager.feedback_path(base_path)
+              item = search_directory_for_id(feedback_dir, id, file_reader)
+              return item if item
+
+              # Search in archive if requested
+              if include_archived
+                archive_dir = dir_manager.archive_path(base_path)
+                item = search_directory_for_id(archive_dir, id, file_reader) if Dir.exist?(archive_dir)
+              end
+
+              item
+            end
+
+            # Search a directory for an item matching the ID
+            def search_directory_for_id(directory, id, file_reader)
+              return nil unless Dir.exist?(directory)
+
+              # Find files matching ID pattern (supports partial)
+              pattern = File.join(directory, "#{id}*.s.md")
+              files = Dir.glob(pattern)
+
+              # If multiple matches, require more specific ID
+              if files.length > 1
+                raise Ace::Support::Cli::Error.new(
+                  "Multiple items match '#{id}': #{files.map { |f| File.basename(f).split("-").first }.join(", ")}. " \
+                  "Please provide more characters."
+                )
+              end
+
+              return nil if files.empty?
+
+              result = file_reader.read(files.first)
+              result[:success] ? result[:feedback_item] : nil
+            end
+
+            # Display item details
+            def display_item(item)
+              puts "=" * 60
+              puts "Feedback: #{item.id}"
+              puts "=" * 60
+              puts
+              puts "Title:    #{item.title}"
+              puts "Status:   #{status_with_icon(item.status)}"
+              puts "Priority: #{item.priority}"
+              puts "Reviewer: #{item.reviewer}"
+              puts "Created:  #{item.created}"
+              puts "Updated:  #{item.updated}"
+              puts
+
+              if item.files && !item.files.empty?
+                puts "Files:"
+                item.files.each { |f| puts "  - #{f}" }
+                puts
+              end
+
+              if item.finding
+                puts "--- Finding ---"
+                puts item.finding
+                puts
+              end
+
+              if item.context
+                puts "--- Context ---"
+                puts item.context
+                puts
+              end
+
+              if item.research
+                puts "--- Research ---"
+                puts item.research
+                puts
+              end
+
+              if item.resolution
+                puts "--- Resolution ---"
+                puts item.resolution
+                puts
+              end
+            end
+
+            # Status with emoji icon
+            def status_with_icon(status)
+              icon = case status
+              when "draft" then "[D]"
+              when "pending" then "[P]"
+              when "invalid" then "[X]"
+              when "skip" then "[S]"
+              when "done" then "[+]"
+              else "[?]"
+              end
+              "#{icon} #{status}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/cli/commands/feedback/skip.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "session_discovery"
+
+module Ace
+  module Review
+    module CLI
+      module Commands
+        module FeedbackSubcommands
+          # ace-support-cli Command class for feedback skip
+          #
+          # Skips a feedback item (marks as not applicable).
+          class Skip < Ace::Support::Cli::Command
+            include Ace::Support::Cli::Base
+            include SessionDiscovery
+
+            desc <<~DESC.strip
+              Skip a feedback item (DEPRECATED - use verify --skip)
+
+              [DEPRECATED] This command is deprecated. Use: verify --skip --research "..."
+
+              Marks a draft or pending feedback item as skipped and archives it.
+              Use when the finding is correct but you are not fixing it in this context.
+
+              Examples of when to skip:
+                - Design decision: Intentionally choosing this approach
+                - Deferred: Correct issue, but tracking in a separate task
+                - Duplicate: Already covered by another feedback item
+
+              For false positives (incorrect findings), use: verify --invalid
+            DESC
+
+            example [
+              "[DEPRECATED] Use: verify --skip instead",
+              "abc123                                                   # Skip without reason",
+              'abc123 --reason "Design: using polling for simplicity"  # Design decision',
+              'abc123 --reason "Tracked in task 253"                    # Deferred to separate task',
+              'abc123 --reason "Duplicate of abc120"                    # Already covered',
+              "abc123 --session .ace-local/review/sessions/review-xyz"
+            ]
+
+            argument :id, required: true, desc: "Feedback ID"
+            option :reason, type: :string, desc: "Reason for skipping (aliased to research)"
+            option :research, type: :string, desc: "Research notes (preferred over --reason)"
+            option :session, type: :string, desc: "Session directory containing feedback"
+
+            # 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(id:, **options)
+              # Show deprecation warning (unless quiet)
+              unless quiet?(options)
+                puts "[DEPRECATED] 'skip' command is deprecated. Use: verify --skip --research \"...\""
+              end
+
+              # Map --reason to --research for consistency
+              research = options[:research] || options[:reason]
+
+              # Resolve feedback path from session context
+              base_path = resolve_feedback_path(options)
+
+              unless base_path
+                raise Ace::Support::Cli::Error.new("No session found. Run a review first or use --session to specify path.")
+              end
+
+              debug_log("Feedback base path: #{base_path}", options)
+
+              # Find item first for partial ID matching
+              resolved_id = resolve_full_id(base_path, id)
+
+              unless resolved_id
+                raise Ace::Support::Cli::Error.new("Feedback item not found: #{id}")
+              end
+
+              # Skip the item using the new verify method with skip: true
+              manager = Organisms::FeedbackManager.new
+              result = manager.verify(
+                base_path,
+                resolved_id,
+                skip: true,
+                research: research
+              )
+
+              if result[:success]
+                puts "Feedback #{resolved_id} skipped and archived."
+                puts "Research: #{research}" if research && !quiet?(options)
+              else
+                raise Ace::Support::Cli::Error.new(result[:error])
+              end
+            end
+
+            private
+
+            # Resolve partial ID to full ID
+            def resolve_full_id(base_path, partial_id)
+              manager = Organisms::FeedbackManager.new
+              feedback_dir = manager.directory_manager.feedback_path(base_path)
+              return nil unless Dir.exist?(feedback_dir)
+
+              # Find files matching ID pattern
+              pattern = File.join(feedback_dir, "#{partial_id}*.s.md")
+              files = Dir.glob(pattern)
+
+              if files.length > 1
+                raise Ace::Support::Cli::Error.new(
+                  "Multiple items match '#{partial_id}': #{files.map { |f| File.basename(f).split("-").first }.join(", ")}. " \
+                  "Please provide more characters."
+                )
+              end
+
+              return nil if files.empty?
+
+              # Extract full ID from filename
+              File.basename(files.first).split("-").first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/cli/commands/feedback/verify.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+require_relative "session_discovery"
+
+module Ace
+  module Review
+    module CLI
+      module Commands
+        module FeedbackSubcommands
+          # ace-support-cli Command class for feedback verify
+          #
+          # Verifies a draft feedback item by marking it as valid or invalid.
+          class Verify < Ace::Support::Cli::Command
+            include Ace::Support::Cli::Base
+            include SessionDiscovery
+
+            desc <<~DESC.strip
+              Verify a draft feedback item
+
+              Marks a draft feedback item as valid, invalid, or skipped.
+
+              Use --valid when: The finding is correct and needs to be fixed
+              Use --invalid when: The finding is a false positive (factually incorrect)
+              Use --skip when: The finding is correct but not being fixed
+
+              Examples of --invalid (false positive):
+                - Claimed code doesn't exist, but it does
+                - Claimed missing validation, but it exists elsewhere
+                - Claimed issue in CI, but code doesn't run in CI
+
+              Examples of --skip (correct but not fixing):
+                - Design decision: Intentionally choosing this approach
+                - Deferred: Correct issue, but tracking in a separate task
+                - Duplicate: Already covered by another feedback item
+            DESC
+
+            example [
+              "abc123 --valid                                    # Correct issue, needs fix",
+              "abc123 --invalid                                  # False positive (incorrect)",
+              "abc123 --skip                                     # Correct but not fixing",
+              'abc123 --valid --research "Confirmed: missing null check at line 42"',
+              'abc123 --invalid --research "False positive: validation exists in middleware"',
+              'abc123 --skip --research "Design: using polling for simplicity"',
+              'abc123 --skip --research "Tracked in task 253"',
+              'abc123 --skip --research "Duplicate of abc120"',
+              "abc123 --valid --session .ace-local/review/sessions/review-xyz"
+            ]
+
+            argument :id, required: true, desc: "Feedback ID"
+            option :valid, type: :boolean, desc: "Mark as valid (moves to pending)"
+            option :invalid, type: :boolean, desc: "Mark as invalid (archives)"
+            option :skip, type: :boolean, desc: "Mark as skipped (archives)"
+            option :research, type: :string, desc: "Add research notes (what we learned/decided)"
+            option :session, type: :string, desc: "Session directory containing feedback"
+
+            # 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(id:, **options)
+              # Validate: must specify exactly one of --valid, --invalid, or --skip
+              mode_count = [options[:valid], options[:invalid], options[:skip]].count { |v| v }
+
+              if mode_count > 1
+                raise Ace::Support::Cli::Error.new("Cannot specify multiple modes. Use exactly one of: --valid, --invalid, --skip.")
+              end
+
+              unless mode_count == 1
+                raise Ace::Support::Cli::Error.new("Must specify exactly one of: --valid, --invalid, --skip.")
+              end
+
+              # Resolve feedback path from session context
+              base_path = resolve_feedback_path(options)
+
+              unless base_path
+                raise Ace::Support::Cli::Error.new("No session found. Run a review first or use --session to specify path.")
+              end
+
+              debug_log("Feedback base path: #{base_path}", options)
+
+              # Find item first for partial ID matching
+              resolved_id = resolve_full_id(base_path, id)
+
+              unless resolved_id
+                raise Ace::Support::Cli::Error.new("Feedback item not found: #{id}")
+              end
+
+              # Verify the item
+              manager = Organisms::FeedbackManager.new
+              result = manager.verify(
+                base_path,
+                resolved_id,
+                valid: if options[:valid] == true
+                         true
+                       else
+                         ((options[:invalid] == true) ? false : nil)
+                       end,
+                skip: (options[:skip] == true) ? true : nil,
+                research: options[:research]
+              )
+
+              if result[:success]
+                status = if options[:valid]
+                  "valid (pending)"
+                elsif options[:invalid]
+                  "invalid (archived)"
+                else
+                  "skipped (archived)"
+                end
+                puts "Feedback #{resolved_id} marked as #{status}."
+                puts "Research: #{options[:research]}" if options[:research] && !quiet?(options)
+              else
+                raise Ace::Support::Cli::Error.new(result[:error])
+              end
+            end
+
+            private
+
+            # Resolve partial ID to full ID
+            def resolve_full_id(base_path, partial_id)
+              manager = Organisms::FeedbackManager.new
+              feedback_dir = manager.directory_manager.feedback_path(base_path)
+              return nil unless Dir.exist?(feedback_dir)
+
+              # Find files matching ID pattern
+              pattern = File.join(feedback_dir, "#{partial_id}*.s.md")
+              files = Dir.glob(pattern)
+
+              if files.length > 1
+                raise Ace::Support::Cli::Error.new(
+                  "Multiple items match '#{partial_id}': #{files.map { |f| File.basename(f).split("-").first }.join(", ")}. " \
+                  "Please provide more characters."
+                )
+              end
+
+              return nil if files.empty?
+
+              # Extract full ID from filename
+              File.basename(files.first).split("-").first
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/review/cli/commands/feedback.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+
+module Ace
+  module Review
+    module CLI
+      module Commands
+        # Base feedback command that shows help for subcommands
+        #
+        # This handles the base "feedback" command:
+        # - No arguments: Show help with available subcommands
+        #
+        # All subcommands (list, show, verify, skip, resolve) are handled
+        # by nested ace-support-cli commands in CLI::Commands::FeedbackSubcommands:: namespace.
+        class Feedback < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Manage feedback items from code reviews
+
+            SYNTAX:
+              ace-review feedback <subcommand> [options]
+
+            SUBCOMMANDS:
+
+              Use 'ace-review feedback <subcommand> --help' for details:
+              - create:  Create feedback items from review reports
+              - list:    List feedback items with optional filters
+              - show:    Show feedback item details
+              - verify:  Verify a draft feedback item (mark valid/invalid/skip)
+              - resolve: Resolve a pending feedback item
+
+            EXAMPLES:
+
+              # Create feedback from most recent session
+              $ ace-review feedback create
+
+              # List all pending feedback items
+              $ ace-review feedback list --status pending
+
+              # Show a specific feedback item
+              $ ace-review feedback show abc123
+
+              # Verify a draft item as valid
+              $ ace-review feedback verify abc123 --valid
+
+              # Resolve a pending item
+              $ ace-review feedback resolve abc123 --resolution "Fixed in commit def456"
+          DESC
+
+          example [
+            "create                   # Create from most recent session",
+            "list --status pending    # List pending items",
+            "show abc123              # Show item details",
+            "verify abc123 --valid    # Mark as valid",
+            "verify abc123 --skip    # Skip (not applicable)",
+            'resolve abc123 --resolution "Fixed"'
+          ]
+
+          def call(**options)
+            # Show help when no subcommand is provided
+            puts "Usage: ace-review feedback <subcommand> [options]"
+            puts
+            puts "Subcommands:"
+            puts "  create   Create feedback items from review reports"
+            puts "  list     List feedback items"
+            puts "  show     Show feedback item details"
+            puts "  verify   Verify a draft feedback item (valid/invalid/skip)"
+            puts "  resolve  Resolve a pending feedback item"
+            puts
+            puts "Run 'ace-review feedback <subcommand> --help' for more information."
+          end
+        end
+      end
+    end
+  end
+end