featureparity 0.0.13 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3dba0cc6ba18239f6952822d96bd4526d26d207e8b7e5448554de745e6517a8
-  data.tar.gz: 1521147f4b1574062b3e04f22cef0ce1cb7ef6b822f767c3f75ed66a200b6a5c
+  metadata.gz: efbe901394a8f97be6d1340a877ecafa6a8151453ed5a78708e91b6e40af1fe1
+  data.tar.gz: 51358f9c7907107f3744775e414f175a1206ace2a104b44dcfcee4723a13e8e4
 SHA512:
-  metadata.gz: a65ac140de45599a9a5a27f4705e179fd816bad77fe563477fd6b92efbc0d592cea80f8c90c2e519d559fc604927d6b321c3a3af99bb10c2b99b9e06b39467f5
-  data.tar.gz: c9ba4966e9a2d036f266b3646eb0c7569399d606d196175df189047de7693c55badce253c94205045449ca7b20117a6f496eeee486067c03ca2291f2caed026f
+  metadata.gz: 16067e82a07cac5e0bf5df3548950ff5d966e8f822ba6315740f474a9d50e17fa25f99adfc9fc4a58a2af66bcd03f3e0edce7e9ab143e05fb6f4b9c2fe2e013e
+  data.tar.gz: 8f58e25f9465851931d0d763f1655b56112cd7899e919af8ee5bf0975fc6ec090c631fc42d993f76dce210468ce4d766cea2c1575b62282f35a969f2124e7530

data/lib/fp/cli.rb

@@ -23,7 +23,10 @@ module Fp
       'setup' => Commands::Setup,
       'whoami' => Commands::Whoami,
       'version' => Commands::Version,
-      'help' => Commands::Help
+      'help' => Commands::Help,
+      'attach' => Commands::Attach,
+      'attachments' => Commands::Attachments,
+      'conversation' => Commands::Conversation
     }.freeze
 
     class << self

data/lib/fp/client.rb

@@ -203,6 +203,84 @@ module Fp
       post("/api/projects/#{project_id}/parity/preview", body)
     end
 
+    # GET /conversations/:id — read a conversation by id alone, regardless of whether
+    # it is project- or account-scoped. The server resolves the owner from the record
+    # and authorizes the caller; the CLI (and the agent using it) never needs to know
+    # or pass the scope. A conversation is just a record.
+    def get_conversation(conversation_id)
+      get("/api/conversations/#{conversation_id}")
+    end
+
+    # --- Attachments ---
+
+    # GET /requirements/:requirement_id/attachments
+    # List all attachments for a requirement.
+    def list_attachments(requirement_id)
+      get("/api/requirements/#{requirement_id}/attachments")
+    end
+
+    # POST /requirements/:requirement_id/attachments/presign
+    # Get a presigned URL for uploading a file.
+    def presign_attachment(requirement_id, filename:, content_type:, size_bytes:)
+      post("/api/requirements/#{requirement_id}/attachments/presign", {
+        filename: filename,
+        content_type: content_type,
+        size_bytes: size_bytes
+      })
+    end
+
+    # POST /requirements/:requirement_id/attachments
+    # Confirm an upload and create the attachment record.
+    def create_attachment(requirement_id, attachment_id:, s3_key:, filename:, content_type:, size_bytes:)
+      post("/api/requirements/#{requirement_id}/attachments", {
+        attachment_id: attachment_id,
+        s3_key: s3_key,
+        filename: filename,
+        content_type: content_type,
+        size_bytes: size_bytes
+      })
+    end
+
+    # GET /requirements/:requirement_id/attachments/:id
+    # Get a presigned download URL for an attachment.
+    def get_attachment(requirement_id, attachment_id)
+      get("/api/requirements/#{requirement_id}/attachments/#{attachment_id}")
+    end
+
+    # DELETE /requirements/:requirement_id/attachments/:id
+    # Delete an attachment.
+    def delete_attachment(requirement_id, attachment_id)
+      delete("/api/requirements/#{requirement_id}/attachments/#{attachment_id}")
+    end
+
+    # Upload a file to S3 using a presigned URL.
+    # This is called after presign_attachment returns the upload_url.
+    def upload_to_presigned_url(url, file_path, content_type)
+      uri = URI.parse(url)
+      file_content = File.binread(file_path)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.open_timeout = 30
+      http.read_timeout = 120 # Allow longer for file upload
+
+      request = Net::HTTP::Put.new(uri)
+      request.body = file_content
+      request['Content-Type'] = content_type
+      request['Content-Length'] = file_content.bytesize.to_s
+
+      response = http.request(request)
+      status = response.code.to_i
+
+      if status >= 200 && status < 300
+        { ok: true, status: status }
+      else
+        { ok: false, error: "S3 upload failed: HTTP #{status}", status: status }
+      end
+    rescue StandardError => e
+      { ok: false, error: "Upload failed: #{e.message}", status: 0 }
+    end
+
     private
 
     def get(path, params = {})
@@ -227,6 +305,12 @@ module Fp
       execute(uri, request)
     end
 
+    def delete(path)
+      uri = build_uri(path)
+      request = Net::HTTP::Delete.new(uri)
+      execute(uri, request)
+    end
+
     def build_uri(path, params = {})
       uri = URI.parse("#{@base_url}#{path}")
       uri.query = URI.encode_www_form(params) unless params.empty?

data/lib/fp/commands/attach.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+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
+    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'
+      }.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
+      end
+
+      private
+
+      def upload_attachment(args)
+        slug = args[0]
+        file_path = args[1]
+
+        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]
+
+        unless content_type
+          Output.error("Unsupported file type: .#{ext}")
+          Output.info("Allowed: #{CONTENT_TYPES.keys.join(', ')}")
+          return 1
+        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
+        end
+
+        # Resolve requirement
+        result = client.find_requirement_by_slug(project_id, slug)
+        unless result[:ok]
+          Output.error(result[:error])
+          return 1
+        end
+
+        requirement = result[:data]['requirement']
+        requirement_id = requirement['id']
+
+        # Step 1: Get presigned URL
+        Output.info("Requesting upload URL for #{filename}...")
+        presign_result = client.presign_attachment(
+          requirement_id,
+          filename: filename,
+          content_type: content_type,
+          size_bytes: file_size
+        )
+
+        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
+
+        # Step 3: Confirm upload
+        Output.info('Confirming upload...')
+        create_result = client.create_attachment(
+          requirement_id,
+          attachment_id: attachment_id,
+          s3_key: s3_key,
+          filename: filename,
+          content_type: content_type,
+          size_bytes: file_size
+        )
+
+        unless create_result[:ok]
+          Output.error("Failed to confirm upload: #{create_result[:error]}")
+          return 1
+        end
+
+        attachment = create_result[:data]['attachment']
+        Output.success("Uploaded #{filename} to requirement '#{slug}'")
+        Output.info("  ID: #{attachment['id']}")
+        0
+      end
+
+      def delete_attachment(args)
+        slug = args[0]
+        attachment_id = args[1]
+
+        if slug.nil? || slug.empty?
+          Output.error('Missing requirement slug. Usage: fp attachment rm <slug> <id>')
+          return 1
+        end
+
+        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 = result[:data]['requirement']
+        requirement_id = requirement['id']
+
+        # Delete attachment
+        delete_result = client.delete_attachment(requirement_id, attachment_id)
+
+        unless delete_result[:ok]
+          Output.error("Failed to delete attachment: #{delete_result[:error]}")
+          return 1
+        end
+
+        Output.success("Deleted attachment #{attachment_id}")
+        0
+      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
+      end
+    end
+  end
+end

data/lib/fp/commands/attachments.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+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
+    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
+
+        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 = result[:data]['requirement']
+        requirement_id = requirement['id']
+
+        if attachment_id
+          show_attachment(requirement_id, attachment_id, slug)
+        else
+          list_attachments(requirement_id, slug)
+        end
+      end
+
+      private
+
+      def list_attachments(requirement_id, slug)
+        result = client.list_attachments(requirement_id)
+
+        unless result[:ok]
+          Output.error(result[:error])
+          return 1
+        end
+
+        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
+        end
+
+        0
+      end
+
+      def show_attachment(requirement_id, attachment_id, slug)
+        result = client.get_attachment(requirement_id, attachment_id)
+
+        unless result[:ok]
+          Output.error(result[:error])
+          return 1
+        end
+
+        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
+        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
+
+        0
+      end
+
+      def format_size(bytes)
+        return '0 bytes' if bytes.nil? || bytes.zero?
+
+        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
+      end
+    end
+  end
+end

data/lib/fp/commands/check.rb

@@ -39,6 +39,7 @@ module Fp
       KNOWN_FLAGS = {
         project: :string,
         surface: :string,
+        test_type: :string,
         level: :string,
         junit: :string,
         base_dir: :string,
@@ -126,7 +127,8 @@ module Fp
 
         results = junit_paths.flat_map do |path|
           testcases = Fp::JUnit.parse_file(path)
-          Fp::JUnit.ci_results(testcases, base_dir: base_dir, default_surface: surface)[:results]
+          Fp::JUnit.ci_results(testcases, base_dir: base_dir, default_surface: surface,
+                                          default_test_type: opts[:test_type])[:results]
         end
 
         if results.empty?
@@ -141,6 +143,7 @@ module Fp
           {
             slug: r.slug,
             surface: r.surface,
+            test_type: r.test_type,
             status: r.status,
             source_file: r.file,
             source_line: r.line,
@@ -219,15 +222,35 @@ module Fp
         return if violations.empty?
 
         puts "#{violations.size} violation(s):"
-        output.table(
-          %w[SLUG SURFACE STATE WHY],
-          violations.map do |v|
-            [v['slug'], v['surface'], "#{Parity.glyph(v['state'])} #{v['state']}", v['reason']]
-          end
-        )
+        # Show the TYPE column only when some requirement demands specific test types —
+        # otherwise it's an empty column of dashes on every project that doesn't use the
+        # feature.
+        if violations.any? { |v| presence(v['test_type']) }
+          output.table(
+            %w[SLUG SURFACE TYPE STATE WHY],
+            violations.map do |v|
+              [v['slug'], v['surface'], v['test_type'] || '—',
+               "#{Parity.glyph(v['state'])} #{v['state']}", v['reason']]
+            end
+          )
+        else
+          output.table(
+            %w[SLUG SURFACE STATE WHY],
+            violations.map do |v|
+              [v['slug'], v['surface'], "#{Parity.glyph(v['state'])} #{v['state']}", v['reason']]
+            end
+          )
+        end
         puts
       end
 
+      # nil/blank → nil, so `presence(x)` reads as falsey in a guard.
+      def presence(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        value
+      end
+
       # Markers the run carried that bind to no requirement in this project — the test
       # claims to cover something that doesn't exist. FP identifies them; it does not
       # propose the requirement, because a slug and a test name aren't enough to write a

data/lib/fp/commands/ci_report.rb

@@ -50,6 +50,7 @@ module Fp
       KNOWN_FLAGS = {
         project: :string,
         surface: :string,
+        test_type: :string,
         ci_url: :string,
         pr: :string,
         junit: :string,
@@ -214,7 +215,8 @@ module Fp
         resolved = Fp::JUnit.ci_results(
           testcases,
           base_dir: opts[:base_dir] || Dir.pwd,
-          default_surface: opts[:surface]
+          default_surface: opts[:surface],
+          default_test_type: opts[:test_type]
         )
 
         {
@@ -222,9 +224,11 @@ module Fp
             {
               slug: r.slug,
               surface: r.surface,
+              test_type: r.test_type,
               status: r.status,
               source_file: r.file,
               source_line: r.line,
+              title: r.title,
               test_count: r.test_count,
               failure_count: r.failure_count
             }

data/lib/fp/commands/conversation.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Fp
+  module Commands
+    # fp conversation <conversation_id>
+    # Read a Pari conversation so agents can review AI suggestions and implement them.
+    #
+    # A conversation is just a record identified by its id — the command doesn't care,
+    # and doesn't ask, whether it came from a project panel or the account-level one.
+    # The server resolves the owner and authorizes the caller. That's the whole point:
+    # a user copies a reference, hands it to an agent, and the agent reads it.
+    #
+    # Typical workflow:
+    #   1. User opens Pari, has a conversation that suggests requirements or code
+    #   2. User clicks "Copy Reference" (or "Copy Prompt") to get the lookup command
+    #   3. User gives it to an agent: "implement what Pari suggested in <id>"
+    #   4. Agent runs `fp conversation <id>` to read the full context
+    #   5. Agent implements based on Pari's suggestions
+    class Conversation < Base
+      def run(args)
+        _opts, positional = parse_flags(args)
+        conversation_id = positional.first
+
+        unless conversation_id
+          output.error(<<~MSG.strip)
+            Conversation ID is required.
+
+            Usage:
+              fp conversation <id>    Read a Pari conversation
+
+            The conversation ID is a KSUID like "03h0abc123xyz...". Copy it from Pari's
+            header (the copy buttons next to the history icon), or use "Copy Reference"
+            to get this whole command ready to paste.
+          MSG
+          exit 1
+        end
+
+        result = client.get_conversation(conversation_id)
+
+        unless result[:ok]
+          output.error(result[:error], status: result[:status])
+          exit 1
+        end
+
+        conversation = result[:data]['conversation']
+        messages = result[:data]['messages'] || []
+
+        output.success(result[:data]) do
+          print_conversation(conversation, messages)
+        end
+      end
+
+      private
+
+      def print_conversation(conversation, messages)
+        title = conversation['title'] || 'Untitled conversation'
+        puts title
+        puts '=' * title.length
+        puts
+        puts "ID:       #{conversation['id']}"
+        puts "Project:  #{conversation['project_id']}" if conversation['project_id'].to_s != ''
+        puts "Status:   #{conversation['status']}"
+        puts "Created:  #{conversation['created_at']}"
+        puts "Updated:  #{conversation['updated_at']}"
+        puts
+
+        if messages.empty?
+          puts '(no messages)'
+        else
+          puts 'Messages:'
+          puts '-' * 40
+          messages.each_with_index do |msg, idx|
+            role = msg['role'] == 'user' ? 'USER' : 'PARI'
+            puts
+            puts "[#{idx + 1}] #{role}:"
+            puts msg['content']
+
+            # Show any requirements Pari created during this turn
+            created = msg['created_requirement_ids'] || []
+            unless created.empty?
+              puts
+              puts "  → Created draft requirement(s): #{created.join(', ')}"
+            end
+
+            puts
+            puts '-' * 40
+          end
+        end
+      end
+    end
+  end
+end