plan_my_stuff 0.10.5 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce0e2f02e6063ab2fe3238671d06182fc5447f428e6dc01d336ba6e00379e86a
-  data.tar.gz: f80f58ce32e19ea6e7b8aca34a62110379e6ea65f10c943fd108c409ec50a669
+  metadata.gz: a34c14adba5975eb4e685f1685c6f4e4cf860cb8013a30b529839de03f87cd19
+  data.tar.gz: ed239a56d7e52e6def2abd9e28929b49be7763945b84c3e3a4384ca2112f187c
 SHA512:
-  metadata.gz: 3aaf1478091d45cbf8caa72a8a0f14b6cc445c5ec7c17382b92d50bb593d36b04ab00ade2973b2e8c67e19b3dfe1b7841022a9f336da2fe7ba3d27ea6c6b7eb5
-  data.tar.gz: 680bbb80160eaa20b20c05d4585e167e143c5be6c4735869bf8d138605cd11a52bacc1f3564cc6b8ea57e772b13aa22bdc7cd720c8254f5cf576c3207b15826e
+  metadata.gz: e779fe0ceff48e299512f96905e0e5b7e9e75b6047a4324b7657b77d4c2a2b21ba6e213d52d72feccb4477930327a3d3d3d9e89f5cb24f2c0502c6a256fd6ef4
+  data.tar.gz: e6242bd7a54f8861aca8d341ab17b569120c6acad8886e10b325f037b211b500939bbc941458a3756b54458bd43961588806129de9aa5718f8a99c6daa393f4d

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.11.0
+
+### Added
+
+- `PlanMyStuff::Attachment` value object (`filename`, `url`) and
+  `CommentMetadata#attachments`. PMS now owns attachment storage:
+  `Comment.create!` accepts an `attachments:` kwarg of uploaded-file
+  objects responding to `#path` and `#original_filename` (e.g.
+  Rails `ActionDispatch::Http::UploadedFile`), `String`/`Pathname`
+  paths to local files, or pre-built `PlanMyStuff::Attachment`
+  instances. Each file is committed to the shared attachment repo
+  (`config.attachment_repo`, default `'pms-attachments'`, under
+  `config.organization`) on `config.main_branch` at
+  `<repo_key>/issue-<N>/<uuid>.<ext>`; the resulting SHA-pinned
+  `raw.githubusercontent.com` permalink is stored in metadata as a
+  `PlanMyStuff::Attachment(filename:, url:)`. The attachment repo
+  must exist; the uploader does not create it. Malformed metadata
+  entries are silently dropped on parse, matching existing `links`
+  / `approvals` behavior on `IssueMetadata`.
+- `config.attachment_repo` (default `'pms-attachments'`) names the
+  bare repo under `config.organization` that stores uploaded
+  attachment binaries.
+- `PlanMyStuff::AttachmentUploader.upload_all!(repo:,
+  issue_number:, files:)` is the underlying uploader; called
+  internally by `Comment.create!` but also usable directly by apps
+  that want to upload before constructing a comment. Pre-built
+  `Attachment` instances pass through without re-uploading.
+- `Issue.create!` accepts an `attachments:` kwarg, forwarded to the
+  body-comment `Comment.create!` call so attachments posted with a
+  new issue are recorded on (and uploaded for) the body comment.
+- `PlanMyStuff::Attachment#download_to(path = nil)` fetches the file
+  via the GitHub Contents API (so it works on private repos) and
+  writes the bytes to disk. Defaults `path` to
+  `File.join(Dir.tmpdir, filename)` and returns the path written to.
+
+### Documented
+
+- `designs/g9/` documents the design pivot from inline-base64 (body
+  size capped) through sibling-repo (rejected) to the chosen
+  side-branch approach.
+
 ## 0.10.5
 
 ### Added

data/lib/plan_my_stuff/attachment.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'tmpdir'
+
+module PlanMyStuff
+  # Value object representing a single attachment record on a +Comment+.
+  # Persisted in +CommentMetadata#attachments+; the gem owns the upload
+  # (see +PlanMyStuff::AttachmentUploader+) and stores a SHA-pinned
+  # +raw.githubusercontent.com+ permalink so the file remains reachable
+  # across later branch rewrites.
+  #
+  # Mirrors +PlanMyStuff::Link+ / +PlanMyStuff::Approval+:
+  # +ActiveModel::Attributes+-backed, with +Serializers::JSON+ for
+  # round-trip through the metadata blob.
+  #
+  class Attachment
+    RAW_URL_REGEX =
+      %r{\Ahttps://raw\.githubusercontent\.com/(?<owner>[^/\s]+)/(?<repo>[^/\s]+)/(?<sha>[^/\s]+)/(?<path>.+)\z}
+
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Serializers::JSON
+
+    # @return [String] display filename (user-provided original name)
+    attribute :filename, :string
+    # @return [String] SHA-pinned raw.githubusercontent.com permalink to the uploaded file
+    attribute :url, :string
+
+    validates :filename, presence: true
+    validates :url, presence: true, format: { with: RAW_URL_REGEX }
+
+    # @return [Hash]
+    def to_h
+      { filename: filename, url: url }
+    end
+
+    # @param other [Object]
+    #
+    # @return [Boolean]
+    #
+    def ==(other)
+      return false unless other.is_a?(PlanMyStuff::Attachment)
+
+      filename == other.filename && url == other.url
+    end
+
+    alias eql? ==
+
+    # @return [Integer]
+    def hash
+      [filename, url].hash
+    end
+
+    # Downloads the file via the GitHub Contents API (so it works on private repos) and writes the bytes to disk.
+    # Defaults the destination to +Dir.tmpdir+ joined with +File.basename(filename)+ (directory components
+    # stripped to prevent path traversal).
+    #
+    # @param path [String, nil] destination path; defaults to +File.join(Dir.tmpdir, File.basename(filename))+
+    #
+    # @return [String] the path the bytes were written to
+    #
+    def download_to(path = nil)
+      path ||= File.join(Dir.tmpdir, File.basename(filename.to_s))
+      match = RAW_URL_REGEX.match(url)
+      body = PlanMyStuff.client.rest(
+        :contents,
+        "#{match[:owner]}/#{match[:repo]}",
+        path: match[:path],
+        ref: match[:sha],
+        accept: 'application/vnd.github.raw',
+      )
+      File.binwrite(path, body)
+      path
+    end
+  end
+end

data/lib/plan_my_stuff/attachment_uploader.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'pathname'
+require 'securerandom'
+
+module PlanMyStuff
+  # Uploads attachment files to a shared attachment repo (+config.attachment_repo+ under +config.organization+) using
+  # GitHub's Git Data API, returning SHA-pinned +raw.githubusercontent.com+ permalinks wrapped in
+  # +PlanMyStuff::Attachment+ instances.
+  #
+  # One commit per batch (atomic): all files in a single +upload_all!+ call land in the same tree/commit so partial
+  # failures cannot leave +config.main_branch+ in an inconsistent state.
+  #
+  # The attachment repo is assumed to exist; the uploader does not create it. Per-source-repo attachments are namespaced
+  # under +<repo_key>/issue-<number>/<uuid>.<ext>+, where +repo_key+ falls back to +repo.name+ for repos resolved
+  # without a +config.repos+ entry.
+  #
+  # @see PlanMyStuff::Attachment
+  #
+  class AttachmentUploader
+    class << self
+      # Uploads each entry in +files+ to the attachment repo and returns the resulting +Attachment+ instances. Order is
+      # not preserved: passthrough +Attachment+ entries are returned before newly-uploaded ones. +Attachment+ entries
+      # are passed through untouched (no upload), supporting round-trip through +Comment#save!+ without
+      # double-uploading.
+      #
+      # Empty / nil +files+ short-circuits with no API calls.
+      #
+      # @param repo [PlanMyStuff::Repo] source issues repo (used to namespace the path)
+      # @param issue_number [Integer]
+      # @param files [Array] mix of already-uploaded +PlanMyStuff::Attachment+ instances, uploaded-file objects
+      #   responding to +#path+ and +#original_filename+ (e.g. Rails +ActionDispatch::Http::UploadedFile+), and
+      #   String/Pathname paths to local files
+      #
+      # @return [Array<PlanMyStuff::Attachment>]
+      #
+      def upload_all!(repo:, issue_number:, files:)
+        entries = Array.wrap(files)
+        return [] if entries.empty?
+
+        slots = entries.map { |entry| classify(entry) }
+        attachments = slots.grep(PlanMyStuff::Attachment)
+        pending = slots.grep(Hash)
+
+        return attachments if pending.blank?
+
+        commit_sha = create_commit!(repo: repo, issue_number: issue_number, pending: pending)
+
+        pending.each do |slot|
+          slot[:attachment] = build_attachment(commit_sha: commit_sha, slot: slot)
+        end
+
+        publish_commit!(commit_sha)
+
+        attachments + pending.pluck(:attachment)
+      end
+
+      private
+
+        # Normalizes a single input entry into a slot Hash or itself (an existing Attachment);
+        # pending slots carry +{filename:, content:}+ awaiting upload.
+        #
+        # @param entry [Object]
+        #
+        # @return [PlanMyStuff::Attachment, Hash]
+        #
+        def classify(entry)
+          if entry.is_a?(PlanMyStuff::Attachment)
+            entry
+          else
+            filename, content = extract_filename_and_content(entry)
+            { filename: filename, content: content }
+          end
+        end
+
+        # @param entry [Object]
+        #
+        # @return [Array(String, String)] filename, raw bytes
+        #
+        def extract_filename_and_content(entry)
+          if entry.respond_to?(:path) && entry.respond_to?(:original_filename)
+            [leaf_filename(entry.original_filename), File.binread(entry.path)]
+          elsif entry.is_a?(String) || entry.is_a?(Pathname)
+            [File.basename(entry), File.binread(entry)]
+          else
+            raise(ArgumentError, "Unsupported attachment entry: #{entry.inspect}")
+          end
+        end
+
+        # Strips directory components (both POSIX and Windows separators) from a browser-supplied filename so
+        # values like +"../../secret.txt"+ or +"C:\\fakepath\\photo.jpg"+ cannot leak into stored metadata or
+        # later download paths.
+        #
+        # @param raw [Object] +original_filename+ from an uploaded-file-like object
+        #
+        # @return [String]
+        #
+        def leaf_filename(raw)
+          name = raw.to_s.tr('\\', '/').split('/').last
+          raise(ArgumentError, 'Attachment filename cannot be blank') if name.blank?
+
+          name
+        end
+
+        # Returns the path-segment used to namespace this source repo's attachments inside the shared attachment repo.
+        # Prefers +repo.key+ (registered repos); falls back to +repo.name+ for repos resolved by full name only.
+        #
+        # @param repo [PlanMyStuff::Repo]
+        #
+        # @return [String]
+        #
+        def namespace_for(repo)
+          (repo.key || repo.name).to_s
+        end
+
+        # Performs the Git Data API dance against the attachment repo and returns the new commit SHA without
+        # publishing it (the ref still points at the old head). Callers must invoke +publish_commit!+ after the
+        # batch has been converted into +Attachment+ instances so a failure during conversion leaves
+        # +config.main_branch+ untouched. Assumes the attachment repo and +config.main_branch+ exist.
+        #
+        # @param repo [PlanMyStuff::Repo] source issues repo
+        # @param issue_number [Integer]
+        # @param pending [Array<Hash>] slots awaiting upload
+        #
+        # @return [String] new commit SHA
+        #
+        def create_commit!(repo:, issue_number:, pending:)
+          client = PlanMyStuff.client
+          head_sha, base_tree_sha = fetch_head_and_tree(client)
+
+          assign_paths!(pending, namespace_for(repo), issue_number)
+          tree_items = pending.map { |slot| blob_tree_item(client, slot) }
+
+          new_tree = client.rest(:create_tree, attachment_repo_full_name, tree_items, base_tree: base_tree_sha)
+          new_tree_sha = dig_sha(new_tree, :sha)
+
+          new_commit = client.rest(
+            :create_commit,
+            attachment_repo_full_name,
+            "task: Add attachments for #{repo.full_name}##{issue_number}",
+            new_tree_sha,
+            [head_sha],
+          )
+          dig_sha(new_commit, :sha)
+        end
+
+        # Updates +config.main_branch+ to point at +commit_sha+. Called as the last step of +upload_all!+ so any
+        # earlier failure leaves the attachment repo unchanged.
+        #
+        # @param commit_sha [String]
+        #
+        # @return [void]
+        #
+        def publish_commit!(commit_sha)
+          PlanMyStuff.client.rest(:update_ref, attachment_repo_full_name, ref, commit_sha)
+        end
+
+        # @param client [PlanMyStuff::Client]
+        #
+        # @return [Array(String, String)] [head_sha, tree_sha]
+        #
+        def fetch_head_and_tree(client)
+          ref_response = client.rest(:ref, attachment_repo_full_name, ref)
+          head_sha = dig_sha(ref_response, :object, :sha)
+          commit_response = client.rest(:commit, attachment_repo_full_name, head_sha)
+          tree_sha = dig_sha(commit_response, :commit, :tree, :sha)
+          [head_sha, tree_sha]
+        end
+
+        # @param pending [Array<Hash>]
+        # @param namespace [String]
+        # @param issue_number [Integer]
+        #
+        # @return [void]
+        #
+        def assign_paths!(pending, namespace, issue_number)
+          pending.each do |slot|
+            uuid = SecureRandom.uuid
+            ext = File.extname(slot[:filename]).delete_prefix('.').downcase
+            basename = ext.empty? ? uuid : "#{uuid}.#{ext}"
+            slot[:basename] = basename
+            slot[:path] = "#{namespace}/issue-#{issue_number}/#{basename}"
+          end
+        end
+
+        # @param client [PlanMyStuff::Client]
+        # @param slot [Hash]
+        #
+        # @return [Hash] tree item ready for create_tree
+        #
+        def blob_tree_item(client, slot)
+          blob_sha = client.rest(
+            :create_blob, attachment_repo_full_name, Base64.strict_encode64(slot[:content]), 'base64',
+          )
+          { path: slot[:path], mode: '100644', type: 'blob', sha: blob_sha }
+        end
+
+        # @param commit_sha [String]
+        # @param slot [Hash]
+        #
+        # @return [PlanMyStuff::Attachment]
+        #
+        def build_attachment(commit_sha:, slot:)
+          url = "https://raw.githubusercontent.com/#{attachment_repo_full_name}/#{commit_sha}/#{slot[:path]}"
+          PlanMyStuff::Attachment.new(filename: slot[:filename], url: url)
+        end
+
+        # @return [String] +"<organization>/<attachment_repo>"+
+        def attachment_repo_full_name
+          "#{PlanMyStuff.configuration.organization}/#{PlanMyStuff.configuration.attachment_repo}"
+        end
+
+        # @return [String] Git ref for the configured main branch (e.g. +"heads/main"+)
+        def ref
+          "heads/#{PlanMyStuff.configuration.main_branch}"
+        end
+
+        # Walks +keys+ through +obj+, tolerating Sawyer resources (method accessors), Hash with Symbol keys, and
+        # Hash with String keys.
+        #
+        # @param obj [Object]
+        # @param keys [Array<Symbol>]
+        #
+        # @return [Object, nil]
+        #
+        def dig_sha(obj, *keys)
+          keys.reduce(obj) do |acc, key|
+            break if acc.nil?
+
+            if acc.respond_to?(key)
+              acc.public_send(key)
+            elsif acc.respond_to?(:[])
+              acc[key] || acc[key.to_s]
+            end
+          end
+        end
+    end
+  end
+end

data/lib/plan_my_stuff/comment.rb

@@ -42,6 +42,10 @@ module PlanMyStuff
       # @param issue_body [Boolean] whether this comment holds the issue body
       # @param waiting_on_reply [Boolean] when true and the author is a support user, marks the issue as waiting on
       #   an end-user reply. Ignored for non-support authors.
+      # @param attachments [Array] files to upload to +config.attachment_repo+ and record on the comment. Each entry
+      #   may be an uploaded-file object responding to +#path+ and +#original_filename+ (e.g. Rails
+      #   +ActionDispatch::Http::UploadedFile+), a String/Pathname path to a local file, or a pre-built
+      #   +PlanMyStuff::Attachment+ instance (passthrough, no re-upload).
       #
       # @return [PlanMyStuff::Comment]
       #
@@ -53,7 +57,8 @@ module PlanMyStuff
         custom_fields: {},
         skip_responded: false,
         issue_body: false,
-        waiting_on_reply: false
+        waiting_on_reply: false,
+        attachments: []
       )
         raise(PlanMyStuff::LockedIssueError, "Issue ##{issue.number} is locked") if issue.locked?
 
@@ -66,6 +71,11 @@ module PlanMyStuff
           issue_body: issue_body,
         )
         comment_metadata.validate_custom_fields!
+        comment_metadata.attachments = PlanMyStuff::AttachmentUploader.upload_all!(
+          repo: issue.repo,
+          issue_number: issue.number,
+          files: attachments,
+        )
 
         header = build_header(resolved_user)
         full_body = "#{header}\n\n#{body}"
@@ -276,6 +286,7 @@ module PlanMyStuff
           custom_fields: metadata.custom_fields.to_h,
           issue_body: metadata.issue_body,
           waiting_on_reply: waiting_on_reply,
+          attachments: metadata.attachments,
         )
         hydrate_from_comment(created)
       else

data/lib/plan_my_stuff/comment_metadata.rb

@@ -4,6 +4,8 @@ module PlanMyStuff
   class CommentMetadata < PlanMyStuff::BaseMetadata
     # @return [Boolean] true if this comment holds the issue's body content
     attr_accessor :issue_body
+    # @return [Array<PlanMyStuff::Attachment>] consuming-app attachment records associated with this comment
+    attr_reader :attachments
 
     class << self
       # Builds a CommentMetadata from a parsed hash (e.g. from MetadataParser)
@@ -16,6 +18,7 @@ module PlanMyStuff
         metadata = new
         apply_common_from_hash(metadata, hash, PlanMyStuff.configuration.custom_fields_for(:comment))
         metadata.issue_body = hash[:issue_body] || false
+        metadata.attachments = hash[:attachments]
 
         metadata
       end
@@ -26,10 +29,11 @@ module PlanMyStuff
       # @param visibility [String] "public" or "internal"
       # @param custom_fields [Hash] app-defined field values
       # @param issue_body [Boolean] whether this comment holds the issue body
+      # @param attachments [Array<Hash, PlanMyStuff::Attachment>] consuming-app attachment records
       #
       # @return [CommentMetadata]
       #
-      def build(user:, visibility: 'internal', custom_fields: {}, issue_body: false)
+      def build(user:, visibility: 'internal', custom_fields: {}, issue_body: false, attachments: [])
         metadata = new
         apply_common_build(
           metadata,
@@ -39,6 +43,7 @@ module PlanMyStuff
           custom_fields_schema: PlanMyStuff.configuration.custom_fields_for(:comment),
         )
         metadata.issue_body = issue_body
+        metadata.attachments = attachments
 
         metadata
       end
@@ -47,6 +52,18 @@ module PlanMyStuff
     def initialize
       super
       @issue_body = false
+      @attachments = []
+    end
+
+    # Assigns +attachments+, normalizing each entry through
+    # +PlanMyStuff::Attachment+ and dropping any malformed ones.
+    #
+    # @param raw [Array, nil]
+    #
+    # @return [Array<PlanMyStuff::Attachment>]
+    #
+    def attachments=(raw)
+      @attachments = normalize_attachments(raw)
     end
 
     # @return [Boolean]
@@ -56,7 +73,46 @@ module PlanMyStuff
 
     # @return [Hash]
     def to_h
-      super.merge(issue_body: issue_body)
+      super.merge(
+        issue_body: issue_body,
+        attachments: attachments.map(&:to_h),
+      )
     end
+
+    private
+
+      # Builds a +PlanMyStuff::Attachment+ from each parsed entry.
+      # Each entry is a +{filename:, url:}+ hash (symbol keys when
+      # built locally, string keys when read back from GitHub
+      # metadata) or an existing +PlanMyStuff::Attachment+.
+      # Malformed hash entries are silently dropped so a single bad
+      # historical entry doesn't crash +Comment.find+. An already-
+      # constructed +Attachment+ that fails validation raises so the
+      # caller is not silently missing an uploaded file.
+      #
+      # @param raw [Array, nil]
+      #
+      # @return [Array<PlanMyStuff::Attachment>]
+      #
+      def normalize_attachments(raw)
+        Array.wrap(raw).filter_map do |entry|
+          next if entry.nil?
+
+          attachment =
+            if entry.is_a?(PlanMyStuff::Attachment)
+              entry
+            elsif entry.respond_to?(:transform_keys)
+              PlanMyStuff::Attachment.new(entry.transform_keys(&:to_sym))
+            end
+          next if attachment.nil?
+
+          attachment.validate!
+          attachment
+        rescue ActiveModel::ValidationError, ArgumentError
+          raise if entry.is_a?(PlanMyStuff::Attachment)
+
+          next
+        end
+      end
   end
 end

data/lib/plan_my_stuff/configuration.rb

@@ -348,9 +348,18 @@ module PlanMyStuff
     #
     attr_accessor :repos
 
+    # Bare repo name (under +config.organization+) that stores uploaded attachment binaries. Defaults to
+    # +'pms-attachments'+. The repo must exist; the uploader does not create it. Attachments commit onto
+    # +config.main_branch+ and live under +<repo_key_or_name>/issue-<number>/<uuid>.<ext>+.
+    #
+    # @return [String]
+    #
+    attr_accessor :attachment_repo
+
     # @return [Configuration]
     def initialize
       @repos = {}
+      @attachment_repo = 'pms-attachments'
       @user_class = 'User'
       @display_name_method = :to_s
       @user_id_method = :id

data/lib/plan_my_stuff/issue.rb

@@ -84,6 +84,11 @@ module PlanMyStuff
       # @param visibility_allowlist [Array<Integer>] user IDs for internal comment access
       # @param issue_type [String, nil] GitHub issue type name (e.g. +"Bug"+, +"Feature"+). Must match a type
       #   configured on the org. +nil+ creates the issue with no type.
+      # @param attachments [Array] files to upload to +config.attachment_repo+ and record on the body comment. Each
+      #   entry may be an uploaded-file object responding to +#path+ and +#original_filename+ (e.g. Rails
+      #   +ActionDispatch::Http::UploadedFile+), a String/Pathname path to a local file, or a pre-built
+      #   +PlanMyStuff::Attachment+ instance (passthrough, no re-upload). Forwarded to the body comment's
+      #   +attachments:+ kwarg; see +Comment.create!+ for full detail.
       #
       # @return [PlanMyStuff::Issue]
       #
@@ -97,7 +102,8 @@ module PlanMyStuff
         add_to_project: nil,
         visibility: 'public',
         visibility_allowlist: [],
-        issue_type: nil
+        issue_type: nil,
+        attachments: []
       )
         if body.blank?
           raise(PlanMyStuff::ValidationError.new('body must be present', field: :body, expected_type: :string))
@@ -151,6 +157,7 @@ module PlanMyStuff
           visibility: issue_metadata.visibility.to_sym,
           skip_responded: true,
           issue_body: true,
+          attachments: attachments,
         )
 
         issue.reload

data/lib/plan_my_stuff/version.rb

@@ -3,8 +3,8 @@
 module PlanMyStuff
   module VERSION
     MAJOR = 0
-    MINOR = 10
-    TINY = 5
+    MINOR = 11
+    TINY = 0
 
     # Set PRE to nil unless it's a pre-release (beta, rc, etc.)
     PRE = nil

data/lib/plan_my_stuff.rb

@@ -8,6 +8,8 @@ require 'active_support/core_ext/object/blank'
 require_relative 'plan_my_stuff/application_record'
 require_relative 'plan_my_stuff/approval'
 require_relative 'plan_my_stuff/archive'
+require_relative 'plan_my_stuff/attachment'
+require_relative 'plan_my_stuff/attachment_uploader'
 require_relative 'plan_my_stuff/base_metadata'
 require_relative 'plan_my_stuff/base_project'
 require_relative 'plan_my_stuff/base_project_item'

data/lib/tasks/plan_my_stuff.rake

@@ -219,6 +219,119 @@ namespace :plan_my_stuff do
     end
   end
 
+  namespace :debug do
+    desc 'Probe GitHub issue body size limit by creating issues of increasing size, then closing them. ' \
+      'Options: REPO=owner/name (default: config.default_repo) START=60000 MAX=70000 STEP=1000 ' \
+      'LABEL=body-size-probe KEEP=0 (set KEEP=1 to leave issues open for inspection)'
+    task body_size_limit: :environment do
+      client = PlanMyStuff.client
+      repo = client.resolve_repo!(ENV.fetch('REPO', nil))
+      start = Integer(ENV.fetch('START', '60000'))
+      max = Integer(ENV.fetch('MAX', '70000'))
+      step = Integer(ENV.fetch('STEP', '1000'))
+      keep = ENV.fetch('KEEP', '0') == '1'
+      label = 'pms-body-size-probe'
+
+      puts("Probing #{repo} body limit: sizes #{start}..#{max} step #{step} " \
+        "label=#{label.inspect} (KEEP=#{keep ? '1' : '0'})")
+      puts
+
+      PlanMyStuff::Label.ensure!(repo: repo, name: label) if label.present?
+
+      created_numbers = []
+
+      start.step(max, step) do |size|
+        header = "<details><summary>#{size} chars</summary>\n\n"
+        footer = "\n\n</details>"
+        inner = 'a' * [size - header.length - footer.length, 0].max
+        body = "#{header}#{inner}#{footer}"
+        title = "[PMS body-size probe] #{size} chars"
+        print(format('size=%-8d ', size))
+
+        begin
+          options = label.present? ? { labels: [label] } : {}
+          result = client.rest(:create_issue, repo, title, body, **options)
+          number = result.respond_to?(:number) ? result.number : result[:number]
+          created_numbers << number
+          puts("OK   ##{number}")
+        rescue Octokit::Error => e
+          puts("FAIL #{e.class}: #{e.message.to_s[0, 200]}")
+          break
+        end
+      end
+
+      puts
+      if keep || created_numbers.empty?
+        puts("Created #{created_numbers.size} issue(s); leaving open (KEEP=1).") if keep
+      else
+        puts("Closing #{created_numbers.size} probe issue(s)...")
+        created_numbers.each do |n|
+          PlanMyStuff::Issue.update!(number: n, repo: repo, state: 'closed')
+        rescue Octokit::Error => e
+          puts("  ##{n}: close failed (#{e.class})")
+        end
+      end
+    end
+
+    desc 'Probe GitHub issue comment body size limit by posting comments of increasing size on a single ' \
+      'bootstrap issue, then closing it. ' \
+      'Options: START=60000 MAX=70000 STEP=1000 KEEP=0 (set KEEP=1 to leave the bootstrap issue open)'
+    task comment_size_limit: :environment do
+      client = PlanMyStuff.client
+      repo = client.resolve_repo!
+      start = Integer(ENV.fetch('START', '60000'))
+      max = Integer(ENV.fetch('MAX', '70000'))
+      step = Integer(ENV.fetch('STEP', '1000'))
+      keep = ENV.fetch('KEEP', '0') == '1'
+      label = 'pms-comment-size-probe'
+
+      puts("Probing #{repo} comment body limit: sizes #{start}..#{max} step #{step} " \
+        "label=#{label.inspect} (KEEP=#{keep ? '1' : '0'})")
+      puts
+
+      PlanMyStuff::Label.ensure!(repo: repo, name: label)
+
+      issue = client.rest(
+        :create_issue,
+        repo,
+        '[PMS comment-size probe] bootstrap',
+        'Bootstrap issue for comment-size probing.',
+        labels: [label],
+      )
+      issue_number = issue.respond_to?(:number) ? issue.number : issue[:number]
+      puts("Bootstrap issue: ##{issue_number}")
+      puts
+
+      start.step(max, step) do |size|
+        header = "<details><summary>#{size} chars</summary>\n\n"
+        footer = "\n\n</details>"
+        inner = 'a' * [size - header.length - footer.length, 0].max
+        body = "#{header}#{inner}#{footer}"
+        print(format('size=%-8d ', size))
+
+        begin
+          client.rest(:add_comment, repo, issue_number, body)
+          puts('OK')
+        rescue Octokit::Error => e
+          puts("FAIL #{e.class}: #{e.message.to_s[0, 200]}")
+          break
+        end
+      end
+
+      puts
+      if keep
+        puts("Leaving bootstrap issue ##{issue_number} open (KEEP=1).")
+      else
+        puts("Closing bootstrap issue ##{issue_number}...")
+        begin
+          PlanMyStuff::Issue.update!(number: issue_number, repo: repo, state: 'closed')
+        rescue Octokit::Error => e
+          puts("  close failed (#{e.class})")
+        end
+      end
+    end
+  end
+
   desc 'Verify PlanMyStuff configuration: token, org, repos, and project access'
   task verify: :environment do
     require 'plan_my_stuff/verifier'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plan_my_stuff
 version: !ruby/object:Gem::Version
-  version: 0.10.5
+  version: 0.11.0
 platform: ruby
 authors:
 - Brands Insurance
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-13 00:00:00.000000000 Z
+date: 2026-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -110,6 +110,8 @@ files:
 - lib/plan_my_stuff/approval.rb
 - lib/plan_my_stuff/archive.rb
 - lib/plan_my_stuff/archive/sweep.rb
+- lib/plan_my_stuff/attachment.rb
+- lib/plan_my_stuff/attachment_uploader.rb
 - lib/plan_my_stuff/aws_sns_simulator.rb
 - lib/plan_my_stuff/base_metadata.rb
 - lib/plan_my_stuff/base_project.rb