featureparity 0.0.16 → 0.0.18

data/lib/fp/commands/attach.rb

@@ -4,186 +4,150 @@ require_relative 'base'
 
 module Fp
   module Commands
-    # Upload, list, and manage attachments on requirements.
-    #
-    # Usage:
-    #   fp attach <slug> <file>       Upload a file to a requirement
-    #   fp attachments <slug>         List attachments for a requirement
-    #   fp attachment <slug> <id>     Get download URL for an attachment
-    #   fp attachment rm <slug> <id>  Delete an attachment
+    # Upload visual test evidence or another supporting file to a requirement.
     class Attach < Base
-      # Allowed content types and their file extensions
       CONTENT_TYPES = {
-        'png' => 'image/png',
-        'jpg' => 'image/jpeg',
-        'jpeg' => 'image/jpeg',
-        'gif' => 'image/gif',
-        'webp' => 'image/webp',
-        'svg' => 'image/svg+xml',
-        'pdf' => 'application/pdf',
-        'txt' => 'text/plain',
-        'md' => 'text/markdown'
+        'png' => 'image/png', 'jpg' => 'image/jpeg', 'jpeg' => 'image/jpeg',
+        'gif' => 'image/gif', 'webp' => 'image/webp', 'svg' => 'image/svg+xml',
+        'mp4' => 'video/mp4', 'webm' => 'video/webm', 'mov' => 'video/quicktime',
+        'pdf' => 'application/pdf', 'txt' => 'text/plain', 'md' => 'text/markdown',
+        'json' => 'application/json'
+      }.freeze
+      VISUAL_EXTENSIONS = %w[png jpg jpeg gif webp mp4 webm mov].freeze
+      MAX_FILE_SIZE = 100 * 1024 * 1024
+      KNOWN_FLAGS = {
+        project: :string,
+        surface: :string,
+        captured_at: :string,
+        deployed_at: :string,
+        deployment_url: :string,
+        test_run_url: :string,
+        sha: :string,
+        example_title: :string,
+        evidence_key: :string
       }.freeze
-
-      MAX_FILE_SIZE = 10 * 1024 * 1024 # 10 MB
 
       def run(args)
-        case args[0]
-        when 'rm', 'delete'
-          delete_attachment(args[1..])
-        else
-          upload_attachment(args)
-        end
+        opts, positional = parse_flags(args, KNOWN_FLAGS)
+        return delete_attachment(opts, positional.drop(1)) if %w[rm delete].include?(positional.first)
+
+        upload_attachment(opts, positional)
       end
 
       private
 
-      def upload_attachment(args)
-        slug = args[0]
-        file_path = args[1]
+      def upload_attachment(opts, positional)
+        slug, file_path = positional
+        return usage_error('Missing requirement slug') if slug.to_s.empty?
+        return usage_error('Missing file path') if file_path.to_s.empty?
+        return command_error("File not found: #{file_path}") unless File.file?(file_path)
 
-        if slug.nil? || slug.empty?
-          Output.error('Missing requirement slug. Usage: fp attach <slug> <file>')
-          return 1
-        end
-
-        if file_path.nil? || file_path.empty?
-          Output.error('Missing file path. Usage: fp attach <slug> <file>')
-          return 1
-        end
-
-        unless File.exist?(file_path)
-          Output.error("File not found: #{file_path}")
-          return 1
-        end
-
-        project_id = require_project_id!
-        return 1 unless project_id
-
-        # Validate file
         filename = File.basename(file_path)
-        ext = File.extname(filename).delete('.').downcase
-        content_type = CONTENT_TYPES[ext]
-
+        extension = File.extname(filename).delete('.').downcase
+        content_type = CONTENT_TYPES[extension]
         unless content_type
-          Output.error("Unsupported file type: .#{ext}")
-          Output.info("Allowed: #{CONTENT_TYPES.keys.join(', ')}")
-          return 1
+          return command_error("Unsupported file type: .#{extension}. Allowed: #{CONTENT_TYPES.keys.join(', ')}")
         end
 
-        file_size = File.size(file_path)
-        if file_size > MAX_FILE_SIZE
-          Output.error("File too large: #{format_size(file_size)} (max #{format_size(MAX_FILE_SIZE)})")
-          return 1
+        size = File.size(file_path)
+        return command_error("File is empty: #{file_path}") if size.zero?
+        if size > MAX_FILE_SIZE
+          return command_error("File too large: #{format_size(size)} (max #{format_size(MAX_FILE_SIZE)})")
         end
-
-        # Resolve requirement
-        result = client.find_requirement_by_slug(project_id, slug)
-        unless result[:ok]
-          Output.error(result[:error])
-          return 1
+        if VISUAL_EXTENSIONS.include?(extension) && opts[:surface].to_s.empty?
+          return command_error('--surface is required for screenshot and video evidence')
         end
 
-        requirement = result[:data]['requirement']
-        requirement_id = requirement['id']
+        require_project!(opts)
+        project_id = resolve_project_id(opts[:project])
+        requirement_result = client.find_requirement_by_slug(project_id, slug)
+        return api_error(requirement_result) unless requirement_result[:ok]
 
-        # Step 1: Get presigned URL
-        Output.info("Requesting upload URL for #{filename}...")
+        requirement_id = requirement_result[:data].dig('requirement', 'id')
         presign_result = client.presign_attachment(
           requirement_id,
           filename: filename,
           content_type: content_type,
-          size_bytes: file_size
+          size_bytes: size
         )
+        return api_error(presign_result, prefix: 'Failed to get upload URL') unless presign_result[:ok]
 
-        unless presign_result[:ok]
-          Output.error("Failed to get upload URL: #{presign_result[:error]}")
-          return 1
-        end
-
-        presign_data = presign_result[:data]['presign']
-        upload_url = presign_data['upload_url']
-        attachment_id = presign_data['attachment_id']
-        s3_key = presign_data['s3_key']
-
-        # Step 2: Upload to S3
-        Output.info("Uploading #{filename} (#{format_size(file_size)})...")
-        upload_result = client.upload_to_presigned_url(upload_url, file_path, content_type)
-
-        unless upload_result[:ok]
-          Output.error("Upload failed: #{upload_result[:error]}")
-          return 1
-        end
+        presign = presign_result[:data]['presign']
+        upload_result = client.upload_to_presigned_url(presign['upload_url'], file_path, content_type)
+        return api_error(upload_result, prefix: 'Upload failed') unless upload_result[:ok]
 
-        # Step 3: Confirm upload
-        Output.info('Confirming upload...')
         create_result = client.create_attachment(
           requirement_id,
-          attachment_id: attachment_id,
-          s3_key: s3_key,
+          attachment_id: presign['attachment_id'],
+          s3_key: presign['s3_key'],
           filename: filename,
           content_type: content_type,
-          size_bytes: file_size
+          size_bytes: size,
+          surface: opts[:surface],
+          captured_at: opts[:captured_at],
+          deployed_at: opts[:deployed_at],
+          deployment_url: opts[:deployment_url],
+          test_run_url: opts[:test_run_url],
+          sha: opts[:sha],
+          example_title: opts[:example_title],
+          evidence_key: opts[:evidence_key]
         )
-
-        unless create_result[:ok]
-          Output.error("Failed to confirm upload: #{create_result[:error]}")
-          return 1
-        end
+        return api_error(create_result, prefix: 'Failed to confirm upload') unless create_result[:ok]
 
         attachment = create_result[:data]['attachment']
-        Output.success("Uploaded #{filename} to requirement '#{slug}'")
-        Output.info("  ID: #{attachment['id']}")
+        output.success({ attachment: attachment }) do
+          puts "Uploaded #{filename} to requirement '#{slug}'."
+          puts "  ID:           #{attachment['id']}"
+          puts "  Surface:      #{attachment['surface']}" if attachment['surface']
+          puts "  Test:         #{attachment['example_title']}" if attachment['example_title']
+          puts "  Evidence key: #{attachment['evidence_key']}" if attachment['evidence_key']
+          puts "  Captured:     #{attachment['captured_at']}" if attachment['captured_at']
+          puts "  Deploy:       #{attachment['deployment_url']}" if attachment['deployment_url']
+          puts '  Deployment context: unknown' if VISUAL_EXTENSIONS.include?(extension) && attachment['deployed_at'].to_s.empty?
+        end
         0
       end
 
-      def delete_attachment(args)
-        slug = args[0]
-        attachment_id = args[1]
+      def delete_attachment(opts, positional)
+        slug, attachment_id = positional
+        return usage_error('Missing requirement slug', delete: true) if slug.to_s.empty?
+        return usage_error('Missing attachment ID', delete: true) if attachment_id.to_s.empty?
 
-        if slug.nil? || slug.empty?
-          Output.error('Missing requirement slug. Usage: fp attachment rm <slug> <id>')
-          return 1
-        end
+        require_project!(opts)
+        project_id = resolve_project_id(opts[:project])
+        requirement_result = client.find_requirement_by_slug(project_id, slug)
+        return api_error(requirement_result) unless requirement_result[:ok]
 
-        if attachment_id.nil? || attachment_id.empty?
-          Output.error('Missing attachment ID. Usage: fp attachment rm <slug> <id>')
-          return 1
-        end
-
-        project_id = require_project_id!
-        return 1 unless project_id
-
-        # Resolve requirement
-        result = client.find_requirement_by_slug(project_id, slug)
-        unless result[:ok]
-          Output.error(result[:error])
-          return 1
-        end
+        requirement_id = requirement_result[:data].dig('requirement', 'id')
+        result = client.delete_attachment(requirement_id, attachment_id)
+        return api_error(result, prefix: 'Failed to delete attachment') unless result[:ok]
 
-        requirement = result[:data]['requirement']
-        requirement_id = requirement['id']
+        output.success({ id: attachment_id, deleted: true }) { puts "Deleted attachment #{attachment_id}." }
+        0
+      end
 
-        # Delete attachment
-        delete_result = client.delete_attachment(requirement_id, attachment_id)
+      def usage_error(message, delete: false)
+        usage = delete ? 'fp attach rm <slug> <id> [--project <project>]' :
+                         'fp attach <slug> <file> [--surface <surface>] [--project <project>]'
+        command_error("#{message}. Usage: #{usage}")
+      end
 
-        unless delete_result[:ok]
-          Output.error("Failed to delete attachment: #{delete_result[:error]}")
-          return 1
-        end
+      def api_error(result, prefix: nil)
+        message = [prefix, result[:error]].compact.join(': ')
+        output.error(message, status: result[:status])
+        1
+      end
 
-        Output.success("Deleted attachment #{attachment_id}")
-        0
+      def command_error(message)
+        output.error(message)
+        1
       end
 
       def format_size(bytes)
-        if bytes >= 1024 * 1024
-          format('%.1f MB', bytes.to_f / (1024 * 1024))
-        elsif bytes >= 1024
-          format('%.1f KB', bytes.to_f / 1024)
-        else
-          "#{bytes} bytes"
-        end
+        return format('%.1f MB', bytes.to_f / (1024 * 1024)) if bytes >= 1024 * 1024
+        return format('%.1f KB', bytes.to_f / 1024) if bytes >= 1024
+
+        "#{bytes} bytes"
       end
     end
   end

data/lib/fp/commands/attachments.rb

@@ -4,118 +4,91 @@ require_relative 'base'
 
 module Fp
   module Commands
-    # List attachments for a requirement, or get a download URL for one.
-    #
-    # Usage:
-    #   fp attachments <slug>         List attachments for a requirement
-    #   fp attachments <slug> <id>    Get download URL for an attachment
+    # List a requirement's attachments, or get a short-lived URL for one.
     class Attachments < Base
-      def run(args)
-        slug = args[0]
-        attachment_id = args[1]
-
-        if slug.nil? || slug.empty?
-          Output.error('Missing requirement slug. Usage: fp attachments <slug> [<id>]')
-          return 1
-        end
+      KNOWN_FLAGS = { project: :string }.freeze
 
-        project_id = require_project_id!
-        return 1 unless project_id
-
-        # Resolve requirement
-        result = client.find_requirement_by_slug(project_id, slug)
-        unless result[:ok]
-          Output.error(result[:error])
+      def run(args)
+        opts, positional = parse_flags(args, KNOWN_FLAGS)
+        slug, attachment_id = positional
+        if slug.to_s.empty?
+          output.error('Missing requirement slug. Usage: fp attachments <slug> [<id>] [--project <project>]')
           return 1
         end
 
-        requirement = result[:data]['requirement']
-        requirement_id = requirement['id']
+        require_project!(opts)
+        project_id = resolve_project_id(opts[:project])
+        requirement_result = client.find_requirement_by_slug(project_id, slug)
+        return api_error(requirement_result) unless requirement_result[:ok]
 
-        if attachment_id
-          show_attachment(requirement_id, attachment_id, slug)
-        else
-          list_attachments(requirement_id, slug)
-        end
+        requirement_id = requirement_result[:data].dig('requirement', 'id')
+        attachment_id ? show_attachment(requirement_id, attachment_id) : list_attachments(requirement_id, slug)
       end
 
       private
 
       def list_attachments(requirement_id, slug)
         result = client.list_attachments(requirement_id)
-
-        unless result[:ok]
-          Output.error(result[:error])
-          return 1
-        end
+        return api_error(result) unless result[:ok]
 
         attachments = result[:data]['attachments'] || []
-
-        if json_output?
-          Output.json({ attachments: attachments })
-          return 0
-        end
-
-        if attachments.empty?
-          Output.info("No attachments for requirement '#{slug}'")
-          return 0
-        end
-
-        Output.info("Attachments for '#{slug}':\n")
-        attachments.each do |att|
-          puts "  #{att['id']}"
-          puts "    Filename: #{att['filename']}"
-          puts "    Type: #{att['content_type']}"
-          puts "    Size: #{format_size(att['size_bytes'])}"
-          puts "    Uploaded by: #{att['uploaded_by']}"
-          puts "    Uploaded at: #{att['created_at']}"
-          puts
+        output.success({ attachments: attachments }) do
+          if attachments.empty?
+            puts "No attachments for requirement '#{slug}'."
+          else
+            puts "Attachments for '#{slug}':"
+            attachments.each do |attachment|
+              puts
+              puts "  #{attachment['id']}  #{attachment['filename']} (#{format_size(attachment['size_bytes'])})"
+              puts "    Surface:    #{attachment['surface']}" if attachment['surface']
+              puts "    Captured:   #{attachment['captured_at']}" if attachment['captured_at']
+              puts "    Deployment: #{deployment_label(attachment)}"
+              puts "    Test run:   #{attachment['test_run_url']}" if attachment['test_run_url']
+            end
+          end
         end
-
         0
       end
 
-      def show_attachment(requirement_id, attachment_id, slug)
+      def show_attachment(requirement_id, attachment_id)
         result = client.get_attachment(requirement_id, attachment_id)
-
-        unless result[:ok]
-          Output.error(result[:error])
-          return 1
-        end
+        return api_error(result) unless result[:ok]
 
         data = result[:data]['attachment_response'] || result[:data]
         attachment = data['attachment']
-        download_url = data['download_url']
-        expires_in = data['expires_in']
-
-        if json_output?
-          Output.json(data)
-          return 0
+        output.success(data) do
+          puts "Attachment: #{attachment['filename']}"
+          puts "  Type:       #{attachment['content_type']}"
+          puts "  Size:       #{format_size(attachment['size_bytes'])}"
+          puts "  Surface:    #{attachment['surface']}" if attachment['surface']
+          puts "  Captured:   #{attachment['captured_at']}" if attachment['captured_at']
+          puts "  Deployment: #{deployment_label(attachment)}"
+          puts
+          puts "View URL (expires in #{data['expires_in'].to_i / 60} minutes):"
+          puts data['download_url']
         end
+        0
+      end
 
-        Output.info("Attachment: #{attachment['filename']}")
-        puts "  ID: #{attachment['id']}"
-        puts "  Type: #{attachment['content_type']}"
-        puts "  Size: #{format_size(attachment['size_bytes'])}"
-        puts "  Uploaded by: #{attachment['uploaded_by']}"
-        puts "  Uploaded at: #{attachment['created_at']}"
-        puts
-        puts "Download URL (expires in #{expires_in / 60} minutes):"
-        puts download_url
+      def deployment_label(attachment)
+        case attachment['deployment_status']
+        when 'after_deployment' then "captured after deploy#{" at #{attachment['deployed_at']}" if attachment['deployed_at']}"
+        when 'predates_deployment' then "capture predates deploy#{" at #{attachment['deployed_at']}" if attachment['deployed_at']}"
+        else 'unknown'
+        end
+      end
 
-        0
+      def api_error(result)
+        output.error(result[:error], status: result[:status])
+        1
       end
 
       def format_size(bytes)
-        return '0 bytes' if bytes.nil? || bytes.zero?
+        bytes = bytes.to_i
+        return format('%.1f MB', bytes.to_f / (1024 * 1024)) if bytes >= 1024 * 1024
+        return format('%.1f KB', bytes.to_f / 1024) if bytes >= 1024
 
-        if bytes >= 1024 * 1024
-          format('%.1f MB', bytes.to_f / (1024 * 1024))
-        elsif bytes >= 1024
-          format('%.1f KB', bytes.to_f / 1024)
-        else
-          "#{bytes} bytes"
-        end
+        "#{bytes} bytes"
       end
     end
   end

data/lib/fp/commands/changed_tests.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Fp
+  module Commands
+    # Lists CI-detected revisions to bound tests and records an agent's assessment of an
+    # exact candidate fingerprint.
+    class ChangedTests < Base
+      CLASSIFICATIONS = %w[still_proves no_longer_proves uncertain].freeze
+      KNOWN_FLAGS = {
+        project: :string,
+        surface: :string,
+        test_type: :string,
+        classification: :string,
+        explanation: :string,
+        candidate_fingerprint: :string
+      }.freeze
+
+      def run(args)
+        opts, positional = parse_flags(args, KNOWN_FLAGS)
+        require_project!(opts)
+        project_id = resolve_project_id(opts[:project])
+
+        if positional.first == 'assess'
+          assess(project_id, positional[1], opts)
+        else
+          list(project_id, opts)
+        end
+      end
+
+      private
+
+      def list(project_id, opts)
+        result = client.list_changed_test_findings(
+          project_id,
+          surface: opts[:surface],
+          test_type: opts[:test_type]
+        )
+        fail_result(result) unless result[:ok]
+
+        data = result[:data] || {}
+        findings = data['changed_test_findings'] || []
+        output.success(data) do
+          if findings.empty?
+            puts 'No unresolved changed-test findings.'
+            next
+          end
+
+          puts "#{findings.length} unresolved changed-test audit finding(s):"
+          findings.each { |finding| print_finding(finding) }
+        end
+      end
+
+      def assess(project_id, finding_id, opts)
+        if finding_id.nil? || finding_id.empty?
+          output.error('Finding id is required. Usage: fp changed-tests assess <id> ...')
+          exit 1
+        end
+
+        classification = opts[:classification].to_s.tr('-', '_')
+        unless CLASSIFICATIONS.include?(classification)
+          output.error("--classification must be one of: #{CLASSIFICATIONS.join(', ')}")
+          exit 1
+        end
+        require_flag(opts, :candidate_fingerprint)
+        require_flag(opts, :explanation)
+        if opts[:explanation].to_s.strip.empty?
+          output.error('--explanation must not be blank')
+          exit 1
+        end
+
+        result = client.assess_changed_test_finding(
+          project_id,
+          finding_id,
+          classification: classification,
+          explanation: opts[:explanation],
+          candidate_fingerprint: opts[:candidate_fingerprint]
+        )
+        fail_result(result) unless result[:ok]
+
+        data = result[:data] || {}
+        output.success(data) do
+          finding = data['changed_test_finding'] || {}
+          puts "Recorded #{classification.tr('_', ' ')} for changed-test finding #{finding_id}."
+          puts "Status: #{finding['status']}"
+          puts 'The CI outcome and requirement wording were not changed.'
+        end
+      end
+
+      def print_finding(finding)
+        requirement = finding['requirement'] || {}
+        testcase = finding['testcase'] || {}
+        accepted = finding['accepted'] || {}
+        candidate = finding['candidate'] || {}
+        assessment = finding['assessment'] || {}
+
+        puts
+        puts "#{finding['id']}  #{requirement['slug']}  [#{finding['surface']}#{type_suffix(finding)}]"
+        puts "  Requirement: #{requirement['title']}"
+        puts "  Acceptance:  #{requirement['acceptance']}"
+        puts "  Testcase:    #{testcase['name']} (#{testcase['outcome']})"
+        puts "  Scope:       #{finding['fingerprint_scope']}"
+        puts "  Accepted:    #{revision_text(accepted)}"
+        puts "  Candidate:   #{revision_text(candidate)}"
+        puts "  Assessment:  #{assessment['classification']}: #{assessment['explanation']}" unless assessment.empty?
+        puts '  Assess:      fp changed-tests assess ' \
+             "#{finding['id']} --candidate-fingerprint #{candidate['fingerprint']} " \
+             '--classification still_proves|no_longer_proves|uncertain --explanation "..."'
+      end
+
+      def type_suffix(finding)
+        type = finding['test_type'].to_s
+        type.empty? || type == 'unspecified' ? '' : ":#{type}"
+      end
+
+      def revision_text(revision)
+        location = revision['source_url'] || [revision['source_file'], revision['start_line']].compact.join(':')
+        "#{revision['fingerprint']} @ #{revision['commit_sha']} #{location}".strip
+      end
+
+      def fail_result(result)
+        output.error(result[:error], status: result[:status])
+        exit 1
+      end
+    end
+  end
+end