plan_my_stuff 0.10.5 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce0e2f02e6063ab2fe3238671d06182fc5447f428e6dc01d336ba6e00379e86a
-  data.tar.gz: f80f58ce32e19ea6e7b8aca34a62110379e6ea65f10c943fd108c409ec50a669
+  metadata.gz: d23d00fb8f2addae60d416beb76a19f81fdf0bb0ce5235453262317c6e351c94
+  data.tar.gz: a83cf20f6347ae27df34133d20b0b10646f5a96346616d0b5594ea4bd965c10f
 SHA512:
-  metadata.gz: 3aaf1478091d45cbf8caa72a8a0f14b6cc445c5ec7c17382b92d50bb593d36b04ab00ade2973b2e8c67e19b3dfe1b7841022a9f336da2fe7ba3d27ea6c6b7eb5
-  data.tar.gz: 680bbb80160eaa20b20c05d4585e167e143c5be6c4735869bf8d138605cd11a52bacc1f3564cc6b8ea57e772b13aa22bdc7cd720c8254f5cf576c3207b15826e
+  metadata.gz: b4cb5444db19f7a551f7296d96145db4e4be90d7897235abd877771dbbc15ffcd3361a4faade94fa521f7e491828c794854d2b0ac97b76e38e7c122f4fc63d07
+  data.tar.gz: a46060793225471181698152cf2681d8be3f64252a845aa2f9e0a838ffc1977f88c81f2b60b28507c8e8a7e7eb64e67016d163d7353d6c9dc9f5faa9b5f8e140

data/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 0.12.0
+
+### Added
+
+- `PlanMyStuff::IssueField` for org-level GitHub Issue Field definitions (public preview).
+  Exposes `.list`, `.find` (case-insensitive), and `#option_id_for!` for resolving
+  single-select option names.
+- `PlanMyStuff::Issue#issue_fields` returns a hash-like `IssueFieldValueSet` view of the
+  field values on an issue. Values are coerced to native types (`Date` for date fields,
+  `Float` for numbers, the option name `String` for single-selects).
+- `PlanMyStuff::Issue#set_issue_fields!(updates)` writes one or more field values in a
+  single GraphQL mutation; passing `nil` as a value clears the field.
+- `issue_fields:` kwarg on `Issue.create!`, `Issue.update!`, `Issue#save!`, and
+  `Issue#update!` so callers can set field values inline with create/update instead of
+  following up with an explicit `set_issue_fields!` call.
+- `Configuration#issue_fields_enabled` (default `true`, opt-out). Set to `false` if your
+  org has not been admitted to the Issue Fields preview - with the flag off,
+  `Issue#issue_fields` returns an empty set and the write paths raise
+  `IssueFieldsNotEnabledError` instead of letting a raw GraphQL error surface.
+
+## 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/CONFIGURATION.md

@@ -192,6 +192,26 @@ config.issue_types = {
 }
 ```
 
+## Issue Fields (public preview)
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `issue_fields_enabled` | `Boolean` | `true` | Whether the Issue Fields public preview is wired up for the org. |
+
+GitHub Issue Fields are structured per-issue metadata (text, number, date, or single-select)
+configured once at the org level. The preview is rolling out org-by-org. Leave this flag at its
+default (`true`) once your org has been admitted; flip to `false` to keep the gem from issuing
+calls that would otherwise return raw GraphQL errors.
+
+With the flag off:
+
+- `Issue#issue_fields` returns an empty `IssueFieldValueSet` without making a request.
+- `Issue#set_issue_fields!(...)` and `IssueField.list` raise `IssueFieldsNotEnabledError`.
+
+```ruby
+config.issue_fields_enabled = false   # org not admitted to the preview yet
+```
+
 ## Release pipeline
 
 | Option | Type | Default | Description |

data/lib/generators/plan_my_stuff/install/templates/initializer.rb

@@ -168,6 +168,16 @@ PlanMyStuff.configure do |config|
   #   'Feature' => 'Enhancement',
   # }
 
+  # --------------------------------------------------------------------------
+  # Issue Fields (public preview)
+  # --------------------------------------------------------------------------
+  # GitHub Issue Fields is a per-org public preview. Default is true (opt-out).
+  # Flip to false if your org has not been admitted to the preview - read paths
+  # return an empty set and write paths raise IssueFieldsNotEnabledError instead
+  # of letting a raw GraphQL error bubble.
+  #
+  # config.issue_fields_enabled = false
+
   # --------------------------------------------------------------------------
   # Release pipeline
   # --------------------------------------------------------------------------

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,27 @@ 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
+
+    # Whether GitHub's Issue Fields (public preview) are wired up for the configured org. Defaults to +true+ (opt-out):
+    # when +false+, +Issue#issue_fields+ returns an empty +IssueFieldValueSet+ without making a request and
+    # +Issue#set_issue_fields!+ / +IssueField.list+ raise +IssueFieldsNotEnabledError+. Set to +false+ if your org has
+    # not been admitted to the Issue Fields preview, to avoid raw GraphQL errors from GitHub.
+    #
+    # @return [Boolean]
+    #
+    attr_accessor :issue_fields_enabled
+
     # @return [Configuration]
     def initialize
       @repos = {}
+      @attachment_repo = 'pms-attachments'
       @user_class = 'User'
       @display_name_method = :to_s
       @user_id_method = :id
@@ -385,6 +403,7 @@ module PlanMyStuff
       @archived_label = 'archived'
       @pipeline_completion_purge_enabled = true
       @pipeline_completion_ttl_hours = 24
+      @issue_fields_enabled = true
       @process_aws_webhooks = Rails.env.production?
       @sns_verifier_class = ::Aws::SNS::MessageVerifier if defined?(::Aws::SNS::MessageVerifier)
       @sns_verifier_error =

data/lib/plan_my_stuff/errors.rb

@@ -106,6 +106,17 @@ module PlanMyStuff
   class LockedIssueError < PlanMyStuff::Error
   end
 
+  # Raised when an Issue Fields API call is attempted while
+  # +config.issue_fields_enabled+ is +false+. Consumers whose org has not been
+  # admitted to the Issue Fields public preview flip the flag off; this error
+  # surfaces faster (and with a clearer message) than the underlying
+  # +GraphQLError+ that GitHub would otherwise return.
+  class IssueFieldsNotEnabledError < PlanMyStuff::Error
+    def initialize(message = nil)
+      super(message || 'Issue Fields are disabled; set config.issue_fields_enabled = true to enable')
+    end
+  end
+
   # Raised by +PlanMyStuff::Pipeline+ forward transitions when the linked
   # +Issue+ has any pending manager approvals.
   class PendingApprovalsError < PlanMyStuff::ValidationError

data/lib/plan_my_stuff/graphql/queries.rb

@@ -399,6 +399,56 @@ module PlanMyStuff
           }
         }
       GRAPHQL
+
+      # --- Issue Fields (org-level public preview) -----------------------
+
+      LIST_ORG_ISSUE_FIELDS = <<~GRAPHQL
+        query($org: String!) {
+          organization(login: $org) {
+            issueFields(first: 50) {
+              nodes {
+                __typename
+                ... on IssueFieldText         { id name description }
+                ... on IssueFieldNumber       { id name description }
+                ... on IssueFieldDate         { id name description }
+                ... on IssueFieldSingleSelect {
+                  id name description
+                  options { id name description color }
+                }
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      READ_ISSUE_FIELD_VALUES = <<~GRAPHQL
+        query($owner: String!, $name: String!, $number: Int!) {
+          repository(owner: $owner, name: $name) {
+            issue(number: $number) {
+              issueFieldValues(first: 50) {
+                nodes {
+                  __typename
+                  ... on IssueFieldTextValue         { value field { ... on IssueFieldText         { id name } } }
+                  ... on IssueFieldNumberValue       { value field { ... on IssueFieldNumber       { id name } } }
+                  ... on IssueFieldDateValue         { value field { ... on IssueFieldDate         { id name } } }
+                  ... on IssueFieldSingleSelectValue {
+                    name optionId
+                    field { ... on IssueFieldSingleSelect { id name } }
+                  }
+                }
+              }
+            }
+          }
+        }
+      GRAPHQL
+
+      SET_ISSUE_FIELD_VALUES = <<~GRAPHQL
+        mutation($issueId: ID!, $issueFields: [IssueFieldCreateOrUpdateInput!]!) {
+          setIssueFieldValue(input: { issueId: $issueId, issueFields: $issueFields }) {
+            issue { number }
+          }
+        }
+      GRAPHQL
     end
   end
 end

data/lib/plan_my_stuff/issue.rb

@@ -84,6 +84,14 @@ 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 issue_fields [Hash{String,Symbol => Object,nil}, nil] GitHub Issue Field values to apply after the
+      #   issue is created. Delegates to +#set_issue_fields!+, so the same coercion rules and
+      #   +IssueFieldsNotEnabledError+ behavior apply. +nil+ or an empty hash is a no-op.
+      # @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,8 +105,14 @@ module PlanMyStuff
         add_to_project: nil,
         visibility: 'public',
         visibility_allowlist: [],
-        issue_type: nil
+        issue_type: nil,
+        issue_fields: nil,
+        attachments: []
       )
+        if issue_fields.present? && !PlanMyStuff.configuration.issue_fields_enabled
+          raise(PlanMyStuff::IssueFieldsNotEnabledError)
+        end
+
         if body.blank?
           raise(PlanMyStuff::ValidationError.new('body must be present', field: :body, expected_type: :string))
         end
@@ -151,8 +165,11 @@ module PlanMyStuff
           visibility: issue_metadata.visibility.to_sym,
           skip_responded: true,
           issue_body: true,
+          attachments: attachments,
         )
 
+        issue.set_issue_fields!(issue_fields) if issue_fields.present?
+
         issue.reload
         PlanMyStuff::Notifications.instrument('issue.created', issue, user: user)
         issue
@@ -180,6 +197,9 @@ module PlanMyStuff
       # @param issue_type [String, nil] GitHub issue type name. Pass a String to set, +nil+ to clear, or omit the
       #   kwarg to leave the current type untouched. (+nil+-vs-omitted is differentiated by the private
       #   +ISSUE_TYPE_UNCHANGED+ sentinel.)
+      # @param issue_fields [Hash{String,Symbol => Object,nil}, nil] GitHub Issue Field values to apply after the
+      #   PATCH (or instead of it, when no other attrs are provided). Delegates to +#set_issue_fields!+, so the same
+      #   coercion rules and +IssueFieldsNotEnabledError+ behavior apply. +nil+ or an empty hash is a no-op.
       #
       # @return [Object]
       #
@@ -192,7 +212,8 @@ module PlanMyStuff
         labels: nil,
         state: nil,
         assignees: nil,
-        issue_type: ISSUE_TYPE_UNCHANGED
+        issue_type: ISSUE_TYPE_UNCHANGED,
+        issue_fields: nil
       )
         client = PlanMyStuff.client
         resolved_repo = client.resolve_repo!(repo)
@@ -229,7 +250,8 @@ module PlanMyStuff
 
         update_body_comment!(number, resolved_repo, body) if body
 
-        return if options.none?
+        updated_issue = find(number, repo: resolved_repo).set_issue_fields!(issue_fields) if issue_fields.present?
+        return updated_issue if options.none?
 
         result = client.rest(:update_issue, resolved_repo, number, **options)
         store_etag_to_cache(client, resolved_repo, number, result, cache_writer: :write_issue)
@@ -550,6 +572,7 @@ module PlanMyStuff
           visibility: metadata.visibility,
           visibility_allowlist: Array.wrap(metadata.visibility_allowlist),
           issue_type: issue_type,
+          issue_fields: @pending_issue_fields,
         )
         hydrate_from_issue(created)
       else
@@ -558,6 +581,7 @@ module PlanMyStuff
         instrument_update(captured_changes, user) unless skip_notification
       end
 
+      @pending_issue_fields = nil
       self
     end
 
@@ -659,6 +683,42 @@ module PlanMyStuff
       safe_read_field(github_response, :id)
     end
 
+    # Returns a hash-like view of GitHub Issue Field values currently set on this issue. Reads on first access and
+    # memoizes; +set_issue_fields!+ invalidates the cache. Returns an empty set without making a request when
+    # +config.issue_fields_enabled+ is +false+.
+    #
+    # @return [PlanMyStuff::IssueFieldValueSet]
+    #
+    def issue_fields
+      @issue_fields ||= load_issue_fields!
+    end
+
+    # Bulk-updates GitHub Issue Field values in a single +setIssueFieldValue+ mutation. Each key is the field display
+    # name; values are coerced to the right input fragment based on the field's type. Passing +nil+ as a value clears
+    # that field.
+    #
+    # @raise [PlanMyStuff::IssueFieldsNotEnabledError] when +config.issue_fields_enabled+ is +false+
+    # @raise [PlanMyStuff::Error] when a referenced field name does not exist on the org
+    #
+    # @param updates [Hash{String,Symbol => Object,nil}]
+    #
+    # @return [self]
+    #
+    def set_issue_fields!(updates)
+      raise(PlanMyStuff::IssueFieldsNotEnabledError) unless PlanMyStuff.configuration.issue_fields_enabled
+
+      fields_by_name = PlanMyStuff::IssueField.list(org: repo.organization).index_by { |field| field.name.downcase }
+      inputs = updates.map { |name, value| build_issue_field_input(fields_by_name, name, value) }
+
+      PlanMyStuff.client.graphql(
+        PlanMyStuff::GraphQL::Queries::SET_ISSUE_FIELD_VALUES,
+        variables: { issueId: github_node_id, issueFields: inputs },
+      )
+
+      @issue_fields = nil
+      self
+    end
+
     private
 
       # Populates this instance from a GitHub API response.
@@ -688,6 +748,7 @@ module PlanMyStuff
         @body_dirty = false
         persisted!
         @comments = nil
+        @issue_fields = nil
         invalidate_links_cache!
       end
 
@@ -715,6 +776,7 @@ module PlanMyStuff
         self.metadata = other.metadata
         persisted!
         @comments = nil
+        @issue_fields = nil
         invalidate_links_cache!
       end
 
@@ -757,6 +819,7 @@ module PlanMyStuff
         }
         attrs[:body] = body if @body_dirty
         attrs[:assignees] = @pending_assignees unless @pending_assignees.nil?
+        attrs[:issue_fields] = @pending_issue_fields if @pending_issue_fields.present?
         attrs[:issue_type] = issue_type if issue_type_changed?
 
         clear_waiting_state_on_close(attrs)
@@ -782,6 +845,7 @@ module PlanMyStuff
         self.body = attrs[:body] if attrs.key?(:body)
         self.issue_type = attrs[:issue_type] if attrs.key?(:issue_type)
         @pending_assignees = attrs[:assignees] if attrs.key?(:assignees)
+        @pending_issue_fields = attrs[:issue_fields] if attrs.key?(:issue_fields)
         apply_metadata_attrs(attrs[:metadata]) if attrs.key?(:metadata)
       end
 
@@ -898,5 +962,47 @@ module PlanMyStuff
 
         id
       end
+
+      # @return [PlanMyStuff::IssueFieldValueSet]
+      def load_issue_fields!
+        return PlanMyStuff::IssueFieldValueSet.new({}) unless PlanMyStuff.configuration.issue_fields_enabled
+
+        data = PlanMyStuff.client.graphql(
+          PlanMyStuff::GraphQL::Queries::READ_ISSUE_FIELD_VALUES,
+          variables: { owner: repo.organization, name: repo.name, number: number },
+        )
+        nodes = data.dig(:repository, :issue, :issueFieldValues, :nodes)
+        PlanMyStuff::IssueFieldValueSet.from_graphql(nodes)
+      end
+
+      # Builds one element of the +issueFields+ argument to the +setIssueFieldValue+ mutation. Looks up the field
+      # definition in the provided hash to pick the right input fragment and (for single-select) resolve the option ID.
+      #
+      # @raise [PlanMyStuff::Error] if the field name is unknown on the org
+      #
+      # @param fields_by_name [Hash{String => PlanMyStuff::IssueField}] fields keyed by downcased display name
+      # @param name [String, Symbol]
+      # @param value [Object, nil]
+      #
+      # @return [Hash]
+      #
+      def build_issue_field_input(fields_by_name, name, value)
+        field = fields_by_name[name.to_s.downcase]
+        raise(PlanMyStuff::Error, "Unknown Issue Field #{name.inspect}") if field.nil?
+
+        return { fieldId: field.id, delete: true } if value.nil?
+
+        case field.type
+        when :single_select then { fieldId: field.id, singleSelectOptionId: field.option_id_for!(value) }
+        when :date then { fieldId: field.id, dateValue: value.to_date.iso8601 }
+        when :number
+          unless value.is_a?(Numeric)
+            raise(PlanMyStuff::Error, "Issue Field #{name.inspect} expects Numeric, got #{value.inspect}")
+          end
+
+          { fieldId: field.id, numberValue: value.to_f }
+        when :text then { fieldId: field.id, textValue: value.to_s }
+        end
+      end
   end
 end

data/lib/plan_my_stuff/issue_field.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  # Value object wrapping an organization-level GitHub Issue Field definition (public preview).
+  # Issue Fields are structured per-issue metadata (text, number, date, or single-select)
+  # configured once at the org level and applied across all of the org's repositories.
+  #
+  # Read-only on the gem side: callers manage field *definitions* through the GitHub UI, while
+  # the gem only handles field *values* on individual issues (see +Issue#issue_fields+).
+  class IssueField
+    # GraphQL +__typename+ -> normalized type symbol used internally.
+    TYPES = {
+      IssueFieldText: :text,
+      IssueFieldNumber: :number,
+      IssueFieldDate: :date,
+      IssueFieldSingleSelect: :single_select,
+    }.freeze
+
+    # @return [String] GraphQL node ID, e.g. +"IFSS_kgDOAAGskA"+
+    attr_reader :id
+
+    # @return [String] display name (e.g. +"Priority"+)
+    attr_reader :name
+
+    # @return [Symbol] one of +:text+, +:number+, +:date+, +:single_select+
+    attr_reader :type
+
+    # @return [String, nil]
+    attr_reader :description
+
+    # @return [Array<Hash>] for +:single_select+, the option list as returned by GraphQL with symbol keys
+    #   (+id+, +name+, +description+, +color+). Empty for other field types.
+    attr_reader :options
+
+    class << self
+      # Lists Issue Field definitions configured on the org.
+      #
+      # @raise [PlanMyStuff::IssueFieldsNotEnabledError] if +config.issue_fields_enabled+ is +false+
+      #
+      # @param org [String, nil] org login; defaults to +config.organization+
+      #
+      # @return [Array<PlanMyStuff::IssueField>]
+      #
+      def list(org: nil)
+        ensure_enabled!
+
+        org_login = org || PlanMyStuff.configuration.organization
+        data = PlanMyStuff.client.graphql(
+          PlanMyStuff::GraphQL::Queries::LIST_ORG_ISSUE_FIELDS,
+          variables: { org: org_login },
+        )
+        Array.wrap(data.dig(:organization, :issueFields, :nodes)).map { |node| from_graphql(node) }
+      end
+
+      # @param name [String, Symbol]
+      # @param org [String, nil]
+      #
+      # @return [PlanMyStuff::IssueField, nil]
+      #
+      def find(name, org: nil)
+        list(org: org).find { |field| field.name.casecmp?(name.to_s) }
+      end
+
+      # @param node [Hash] one node from +LIST_ORG_ISSUE_FIELDS+
+      #
+      # @return [PlanMyStuff::IssueField]
+      #
+      def from_graphql(node)
+        typename = node[:__typename]
+        type = TYPES[typename.to_sym] if typename
+        raise(PlanMyStuff::Error, "Unknown Issue Field typename: #{typename.inspect}") if type.nil?
+
+        new(
+          id: node.fetch(:id),
+          name: node.fetch(:name),
+          type: type,
+          description: node[:description],
+          options: Array.wrap(node[:options]),
+        )
+      end
+
+      private
+
+        # @raise [PlanMyStuff::IssueFieldsNotEnabledError]
+        #
+        # @return [void]
+        #
+        def ensure_enabled!
+          return if PlanMyStuff.configuration.issue_fields_enabled
+
+          raise(PlanMyStuff::IssueFieldsNotEnabledError)
+        end
+    end
+
+    # @param id [String]
+    # @param name [String]
+    # @param type [Symbol]
+    # @param description [String, nil]
+    # @param options [Array<Hash>]
+    #
+    def initialize(id:, name:, type:, description: nil, options: [])
+      @id = id
+      @name = name
+      @type = type
+      @description = description
+      @options = options
+    end
+
+    # Resolves a single-select option name to its GraphQL node ID.
+    #
+    # @raise [PlanMyStuff::Error] if this field is not a single-select, or the option name is unknown
+    #
+    # @param option_name [String, Symbol]
+    #
+    # @return [String]
+    #
+    def option_id_for!(option_name)
+      raise(PlanMyStuff::Error, "Field #{name.inspect} is not a single-select") unless type == :single_select
+
+      match = options.find { |option| option.fetch(:name).casecmp?(option_name.to_s) }
+      raise(PlanMyStuff::Error, "Unknown option #{option_name.inspect} for field #{name.inspect}") if match.nil?
+
+      match.fetch(:id)
+    end
+  end
+end

data/lib/plan_my_stuff/issue_field_value_set.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module PlanMyStuff
+  # Hash-like read-side view of GitHub Issue Field values on a single +Issue+. Returned by
+  # +Issue#issue_fields+. Values are coerced into Ruby types on construction: date fields come back
+  # as +Date+, number fields as +Float+, single-select fields as the option name +String+, and
+  # text fields as the raw +String+.
+  #
+  # Access is by field display name; string and symbol keys both work. Iteration yields
+  # +[name, value]+ pairs in the order GitHub returned them.
+  class IssueFieldValueSet
+    include Enumerable
+
+    delegate :empty?, to: :@hash
+
+    class << self
+      # @param nodes [Array<Hash>, nil] +issueFieldValues.nodes+ from the GraphQL read query
+      #
+      # @return [PlanMyStuff::IssueFieldValueSet]
+      #
+      def from_graphql(nodes)
+        pairs = Array.wrap(nodes).map { |node| [node.dig(:field, :name), coerce(node)] }
+        new(pairs.to_h)
+      end
+
+      # @param node [Hash]
+      #
+      # @return [Object]
+      #
+      def coerce(node)
+        case node[:__typename].to_s
+        when 'IssueFieldDateValue' then Date.parse(node.fetch(:value))
+        when 'IssueFieldNumberValue' then node.fetch(:value).to_f
+        when 'IssueFieldSingleSelectValue' then node.fetch(:name)
+        else node.fetch(:value)
+        end
+      end
+    end
+
+    # @param hash [Hash{String => Object}]
+    #
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # @param name [String, Symbol] field display name
+    #
+    # @return [Object, nil]
+    #
+    def [](name)
+      @hash[name.to_s]
+    end
+
+    # @return [Hash{String => Object}] copy of the underlying hash
+    def to_h
+      @hash.dup
+    end
+
+    # @return [Enumerator, void]
+    def each(&)
+      @hash.each(&)
+    end
+  end
+end

data/lib/plan_my_stuff/version.rb

@@ -3,8 +3,8 @@
 module PlanMyStuff
   module VERSION
     MAJOR = 0
-    MINOR = 10
-    TINY = 5
+    MINOR = 12
+    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'
@@ -22,6 +24,8 @@ require_relative 'plan_my_stuff/engine' if defined?(Rails)
 require_relative 'plan_my_stuff/errors'
 require_relative 'plan_my_stuff/graphql/queries'
 require_relative 'plan_my_stuff/issue'
+require_relative 'plan_my_stuff/issue_field'
+require_relative 'plan_my_stuff/issue_field_value_set'
 require_relative 'plan_my_stuff/issue_metadata'
 require_relative 'plan_my_stuff/label'
 require_relative 'plan_my_stuff/link'

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.12.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
@@ -130,6 +132,8 @@ files:
 - lib/plan_my_stuff/issue_extractions/links.rb
 - lib/plan_my_stuff/issue_extractions/viewers.rb
 - lib/plan_my_stuff/issue_extractions/waiting.rb
+- lib/plan_my_stuff/issue_field.rb
+- lib/plan_my_stuff/issue_field_value_set.rb
 - lib/plan_my_stuff/issue_metadata.rb
 - lib/plan_my_stuff/label.rb
 - lib/plan_my_stuff/link.rb