issuer 0.1.1 → 0.2.1

data/lib/issuer/apis/github/client.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require 'octokit'
+require 'ostruct'
+require 'json'
+require 'net/http'
+require 'uri'
 
 module Issuer
   module APIs
@@ -24,6 +28,18 @@ module Issuer
             raise Issuer::Error, "Issue title is required"
           end
 
+          # If type is specified, use GraphQL API
+          if issue_params[:type]
+            return create_issue_with_type(repo, issue_params)
+          end
+
+          # Otherwise use REST API
+          create_issue_rest(repo, issue_params)
+        rescue Octokit::Error => e
+          raise Issuer::Error, "GitHub API error: #{e.message}"
+        end
+
+        def create_issue_rest repo, issue_params
           # Prepare issue creation parameters
           params = {
             title: issue_params[:title],
@@ -47,8 +63,87 @@ module Issuer
           end
 
           @client.create_issue(repo, params[:title], params[:body], params)
-        rescue Octokit::Error => e
-          raise Issuer::Error, "GitHub API error: #{e.message}"
+        end
+
+        def create_issue_with_type repo, issue_params
+          # Get repository owner and name
+          owner, name = repo.split('/')
+          
+          # Get issue type ID
+          issue_type_id = resolve_issue_type(repo, issue_params[:type])
+          unless issue_type_id
+            puts "⚠️  Warning: Issue type '#{issue_params[:type]}' not found. Falling back to REST API."
+            # Add type as a label when issue type is not found
+            fallback_params = issue_params.dup
+            type_label = "type:#{fallback_params[:type]}"
+            fallback_params[:labels] = (fallback_params[:labels] || []) + [type_label]
+            fallback_params.delete(:type)  # Remove type since REST API doesn't support it
+            puts "⚠️  Adding label '#{type_label}' to preserve type information."
+            return create_issue_rest(repo, fallback_params)
+          end
+
+          # Prepare GraphQL input
+          input = {
+            repositoryId: get_repository_id(owner, name),
+            title: issue_params[:title],
+            body: issue_params[:body] || '',
+            issueTypeId: issue_type_id
+          }
+
+          # Handle labels
+          if issue_params[:labels] && !issue_params[:labels].empty?
+            input[:labelIds] = resolve_label_ids(repo, issue_params[:labels])
+          end
+
+          # Handle assignee
+          if issue_params[:assignee] && !issue_params[:assignee].strip.empty?
+            input[:assigneeIds] = [get_user_id(issue_params[:assignee])]
+          end
+
+          # Handle milestone
+          if issue_params[:milestone]
+            milestone = find_milestone(repo, issue_params[:milestone])
+            input[:milestoneId] = milestone.node_id if milestone
+          end
+
+          # Execute GraphQL mutation
+          mutation = <<~GRAPHQL
+            mutation CreateIssue($input: CreateIssueInput!) {
+              createIssue(input: $input) {
+                issue {
+                  id
+                  number
+                  title
+                  body
+                  url
+                  createdAt
+                }
+              }
+            }
+          GRAPHQL
+
+          result = execute_graphql_query(mutation, { "input" => input })
+
+          # Convert GraphQL response to REST-like format for compatibility
+          issue_data = result["data"]["createIssue"]["issue"]
+          OpenStruct.new(
+            number: issue_data["number"],
+            title: issue_data["title"],
+            body: issue_data["body"],
+            html_url: issue_data["url"],
+            created_at: issue_data["createdAt"]
+          )
+        rescue => e
+          puts "⚠️  Warning: GraphQL issue creation failed: #{e.message}. Falling back to REST API."
+          # Add type as a label when GraphQL fails
+          fallback_params = issue_params.dup
+          if fallback_params[:type]
+            type_label = "type:#{fallback_params[:type]}"
+            fallback_params[:labels] = (fallback_params[:labels] || []) + [type_label]
+            fallback_params.delete(:type)  # Remove type since REST API doesn't support it
+            puts "⚠️  Adding label '#{type_label}' to preserve type information."
+          end
+          create_issue_rest(repo, fallback_params)
         end
 
         def find_milestone repo, milestone_title
@@ -100,13 +195,35 @@ module Issuer
           @client.rate_limit
         end
 
+        def get_issue_types repo
+          owner, name = repo.split('/')
+          query = <<~GRAPHQL
+            query GetIssueTypes($owner: String!, $name: String!) {
+              repository(owner: $owner, name: $name) {
+                issueTypes(first: 20) {
+                  nodes {
+                    id
+                    name
+                    description
+                  }
+                }
+              }
+            }
+          GRAPHQL
+
+          result = execute_graphql_query(query, { owner: owner, name: name })
+          result['data']['repository']['issueTypes']['nodes']
+        rescue => e
+          raise Issuer::Error, "Error fetching issue types: #{e.message}"
+        end
+
         private
 
         def default_token_env_vars
           %w[ISSUER_API_TOKEN ISSUER_GITHUB_TOKEN GITHUB_ACCESS_TOKEN GITHUB_TOKEN]
         end
 
-        def detect_github_token(custom_env_var)
+        def detect_github_token custom_env_var
           # Check custom env var first if provided
           return ENV[custom_env_var] if custom_env_var && ENV[custom_env_var]
 
@@ -118,6 +235,69 @@ module Issuer
 
           nil
         end
+
+        # GraphQL helper methods
+        def resolve_issue_type repo, type_name
+          issue_types = get_issue_types(repo)
+          issue_type = issue_types.find { |type| type['name'].downcase == type_name.downcase }
+          issue_type&.[]('id')
+        end
+
+        def get_repository_id owner, name
+          query = <<~GRAPHQL
+            query GetRepository($owner: String!, $name: String!) {
+              repository(owner: $owner, name: $name) {
+                id
+              }
+            }
+          GRAPHQL
+
+          result = execute_graphql_query(query, { owner: owner, name: name })
+          result['data']['repository']['id']
+        end
+
+        def resolve_label_ids repo, label_names
+          # For now, we'll skip complex label ID resolution
+          # GitHub GraphQL API requires label IDs, but REST API uses names
+          # This is a simplification - in practice, you'd need to fetch and match labels
+          []
+        end
+
+        def get_user_id username
+          query = <<~GRAPHQL
+            query GetUser($login: String!) {
+              user(login: $login) {
+                id
+              }
+            }
+          GRAPHQL
+
+          result = execute_graphql_query(query, { login: username })
+          result['data']['user']['id']
+        end
+
+        def execute_graphql_query query, variables = {}
+          uri = URI.parse("https://api.github.com/graphql")
+          request = Net::HTTP::Post.new(uri)
+          request.content_type = "application/json"
+          request["Authorization"] = "Bearer #{@token}"
+          request.body = JSON.dump({
+            "query" => query,
+            "variables" => variables
+          })
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(request)
+          end
+
+          result = JSON.parse(response.body)
+
+          if result["errors"] && !result["errors"].empty?
+            raise Issuer::Error, "GraphQL error: #{result["errors"].first['message']}"
+          end
+
+          result
+        end
       end
     end
   end

data/lib/issuer/cache.rb

@@ -32,7 +32,7 @@ module Issuer
       FileUtils.mkdir_p(logs_dir) unless Dir.exist?(logs_dir)
     end
 
-    def run_log_file(run_id)
+    def run_log_file run_id
       File.join(logs_dir, "#{run_id}.json")
     end
 
@@ -43,7 +43,7 @@ module Issuer
     end
 
     # Run tracking
-    def start_run(metadata = {})
+    def start_run metadata = {}
       ensure_cache_directories
 
       run_id = generate_run_id
@@ -68,7 +68,7 @@ module Issuer
       run_id
     end
 
-    def complete_run(run_id, issues_processed = nil)
+    def complete_run run_id, issues_processed = nil
       run_data = load_run_log(run_id)
       return unless run_data
 
@@ -89,7 +89,7 @@ module Issuer
       save_run_log(run_id, run_data)
     end
 
-    def fail_run(run_id, error_message)
+    def fail_run run_id, error_message
       run_data = load_run_log(run_id)
       return unless run_data
 
@@ -105,19 +105,19 @@ module Issuer
     end
 
     # Artifact tracking
-    def log_issue_created(run_id, issue_data)
+    def log_issue_created run_id, issue_data
       log_artifact(run_id, :issues, issue_data)
     end
 
-    def log_milestone_created(run_id, milestone_data)
+    def log_milestone_created run_id, milestone_data
       log_artifact(run_id, :milestones, milestone_data)
     end
 
-    def log_label_created(run_id, label_data)
+    def log_label_created run_id, label_data
       log_artifact(run_id, :labels, label_data)
     end
 
-    def log_artifact(run_id, type, artifact_data)
+    def log_artifact run_id, type, artifact_data
       run_data = load_run_log(run_id)
       return unless run_data
 
@@ -150,11 +150,11 @@ module Issuer
     end
 
     # Data persistence
-    def save_run_log(run_id, data)
+    def save_run_log run_id, data
       File.write(run_log_file(run_id), JSON.pretty_generate(data))
     end
 
-    def load_run_log(run_id)
+    def load_run_log run_id
       log_file = run_log_file(run_id)
       return nil unless File.exist?(log_file)
 
@@ -165,7 +165,7 @@ module Issuer
     end
 
     # Query and listing
-    def list_runs(status: nil, limit: nil)
+    def list_runs status: nil, limit: nil
       ensure_cache_directories
 
       log_files = Dir.glob(File.join(logs_dir, '*.json'))
@@ -185,11 +185,11 @@ module Issuer
       limit ? runs.take(limit) : runs
     end
 
-    def get_run(run_id)
+    def get_run run_id
       load_run_log(run_id)
     end
 
-    def delete_run_log(run_id)
+    def delete_run_log run_id
       log_file = run_log_file(run_id)
       File.delete(log_file) if File.exist?(log_file)
     end

data/lib/issuer/cli.rb

@@ -15,7 +15,7 @@ module Issuer
     class_option :proj, type: :string, desc: 'Override $meta.proj (org/repo)'
     class_option :vrsn, type: :string, desc: 'Default version for all issues'
     class_option :user, type: :string, desc: 'Default assignee (GitHub username)'
-    class_option :tags, type: :string, desc: 'Comma-separated extra labels for all issues'
+    class_option :tags, type: :string, desc: 'Comma-separated default or appended (+) labels for all issues'
     class_option :stub, type: :boolean, desc: 'Enable stub mode for all issues'
     class_option :dry, type: :boolean, default: false, aliases: ['--dry-run'], desc: 'Print issues, don\'t post'
     class_option :tokenv, type: :string, desc: 'Name of environment variable containing GitHub token'
@@ -167,12 +167,11 @@ module Issuer
       Issue Default Options:
         --vrsn VERSION           #{self.class_options[:vrsn].description}
         --user USERNAME          #{self.class_options[:user].description}
-        --tags tag1,tag2         #{self.class_options[:tags].description}
+        --tags tag1,+tag2        #{self.class_options[:tags].description}
         --stub                   #{self.class_options[:stub].description}
 
       Site Options:
         --proj org/repo          #{self.class_options[:proj].description}
-        --tokenv VAR_NAME        #{self.class_options[:tokenv].description}
 
       Mode Options:
         --dry, --dry-run         #{self.class_options[:dry].description}
@@ -184,7 +183,7 @@ module Issuer
 
       Info:
         -h, --help               #{self.class_options[:help].description}
-        -v, --version            #{self.class_options[:version].description}
+        --version                Show version
 
       Examples:
         issuer issues.yml --dry
@@ -196,7 +195,6 @@ module Issuer
 
       Authentication:
       Set GITHUB_TOKEN environment variable with your GitHub personal access token
-      Or use --tokenv to specify a custom environment variable name
 
       HELP
     end

data/lib/issuer/issue.rb

@@ -15,6 +15,7 @@ module Issuer
   # +tags+:: Array of labels to apply
   # +user+:: Assignee username
   # +vrsn+:: Milestone/version
+  # +type+:: Issue type (e.g., Bug, Feature, Task)
   # +stub+:: Whether to apply stub text composition
   #
   # == Tag Logic
@@ -22,6 +23,7 @@ module Issuer
   # Tags support special prefix notation:
   # * Regular tags (e.g., +"bug"+) are only applied if the issue has no existing tags
   # * Append tags (e.g., +"+urgent"+) are always applied to all issues
+  # * Removal tags (e.g., +"-needs:docs"+) are removed from the default/appended tags list
   #
   # == Stub Composition
   #
@@ -50,7 +52,7 @@ module Issuer
   #   valid_issues = Issuer::Issue.valid_issues_from_array(array_of_data, defaults)
   #
   class Issue
-    attr_reader :summ, :tags, :user, :vrsn, :raw_data
+    attr_reader :summ, :tags, :user, :vrsn, :type, :raw_data
     attr_accessor :body, :stub
 
     ##
@@ -60,7 +62,12 @@ module Issuer
     # @param defaults [Hash] Default values to apply when issue data is missing properties
     #
     def initialize issue_data, defaults={}
-      @raw_data = issue_data || {}
+      # Handle string issues (simple format where string is the summary)
+      if issue_data.is_a?(String)
+        @raw_data = { 'summ' => issue_data }
+      else
+        @raw_data = issue_data || {}
+      end
       @defaults = defaults
       
       # For most fields, issue data overrides defaults
@@ -68,6 +75,7 @@ module Issuer
       @body = @raw_data['body'] || @raw_data['desc'] || defaults['body'] || defaults['desc'] || '' # Support both body and desc (legacy)
       @user = @raw_data['user'] || defaults['user']
       @vrsn = @raw_data['vrsn'] || defaults['vrsn']
+      @type = @raw_data['type'] || defaults['type']
       @stub = @raw_data.key?('stub') ? @raw_data['stub'] : defaults['stub']
       
       # For tags, we need special handling - combine defaults and issue tags for later processing
@@ -162,28 +170,32 @@ module Issuer
 
     # Apply tag logic for this issue
     # 
-    # Processes existing tags with + prefix as append tags, combines them with
-    # CLI-provided tags, and determines final tag set based on precedence rules.
+    # Processes existing tags with + prefix as append tags, - prefix as removal tags,
+    # combines them with CLI-provided tags, and determines final tag set based on precedence rules.
     # 
     # @param cli_append_tags [Array<String>] Tags to always append from CLI
     # @param cli_default_tags [Array<String>] Default tags from CLI (used when no regular tags exist)
     # @return [void] Sets @tags instance variable
     # 
     # @example
-    #   # Issue has tags: ['+urgent', 'bug']
-    #   issue.apply_tag_logic(['cli-tag'], ['default-tag'])
-    #   # Result: ['urgent', 'cli-tag', 'bug']
+    #   # Issue has tags: ['+urgent', 'bug', '-needs:docs']
+    #   issue.apply_tag_logic(['cli-tag'], ['default-tag', 'needs:docs'])
+    #   # Result: ['urgent', 'cli-tag', 'bug', 'default-tag'] (needs:docs removed)
     def apply_tag_logic cli_append_tags, cli_default_tags
-      # Parse existing tags for + prefix
+      # Parse existing tags for + and - prefixes
       existing_tags = tags || []
       append_tags = []
       regular_tags = []
+      remove_tags = []
 
       existing_tags.each do |tag|
-        if tag.to_s.start_with?('+')
-          append_tags << tag.to_s[1..] # Remove + prefix
+        tag_str = tag.to_s
+        if tag_str.start_with?('+')
+          append_tags << tag_str[1..] # Remove + prefix
+        elsif tag_str.start_with?('-')
+          remove_tags << tag_str[1..] # Remove - prefix
         else
-          regular_tags << tag.to_s
+          regular_tags << tag_str
         end
       end
 
@@ -192,7 +204,7 @@ module Issuer
       final_tags = append_tags + defaults_append_tags + cli_append_tags
 
       # For regular tags, add issue's own tags, otherwise use default tags
-      issue_regular_tags = Array(@raw_data['tags']).reject { |tag| tag.to_s.start_with?('+') }
+      issue_regular_tags = Array(@raw_data['tags']).reject { |tag| tag.to_s.start_with?('+') || tag.to_s.start_with?('-') }
 
       if !issue_regular_tags.empty?
         # Issue has its own regular tags, use them
@@ -200,13 +212,19 @@ module Issuer
       else
         # Issue has no regular tags, use defaults from CLI
         final_tags.concat(cli_default_tags)
-        # Also add non-append defaults tags
+        # Also add non-append defaults tags (- prefix ignored in defaults)
         defaults_regular_tags = Array(@defaults['tags']).reject { |tag| tag.to_s.start_with?('+') }
         final_tags.concat(defaults_regular_tags)
       end
 
-      # Set the final tags (removing duplicates)
-      @tags = final_tags.uniq
+      # Collect removal tags from issue only (not defaults)
+      all_remove_tags = remove_tags
+      
+      # Remove duplicates first, then remove tags specified for removal
+      final_tags = final_tags.uniq - all_remove_tags
+      
+      # Set the final tags
+      @tags = final_tags
     end
 
     # Apply stub logic for this issue
@@ -252,7 +270,8 @@ module Issuer
     # 
     # Separates tags with + prefix (append tags) from regular tags (default tags).
     # Tags with + prefix are always applied, while regular tags are only used
-    # when the issue has no existing regular tags.
+    # when the issue has no existing regular tags. Tags with - prefix are handled
+    # in the apply_tag_logic method for removal.
     # 
     # @param tags_string [String] Comma-separated tag string
     # @return [Array<Array<String>>] Two-element array: [append_tags, default_tags]
@@ -299,14 +318,14 @@ module Issuer
     #               Users cannot log in properly after the recent update.
     #               This affects all user accounts.
     #   
-    #   repo:       myorg/myproject
+    #   type:       Bug
     #   milestone:  1.0.0
     #   labels:
     #     - bug
     #     - urgent
     #   assignee:   developer1
     #   ------
-    def formatted_output(site, repo)
+    def formatted_output site, repo
       # Get site-specific field mappings
       field_map = site.field_mappings
       
@@ -323,17 +342,22 @@ module Issuer
       if site_params[:body] && !site_params[:body].strip.empty?
         body_field = field_map[:body] || 'body'
         output << "#{body_field}:"
-        # Indent body content
+        # Indent body content with proper line wrapping
         body_lines = site_params[:body].strip.split("\n")
         body_lines.each do |line|
-          output << "            #{line}"
+          wrapped_lines = wrap_line_with_indentation(line, 12)
+          wrapped_lines.each do |wrapped_line|
+            output << wrapped_line
+          end
         end
         output << ""  # Empty line after body
       end
       
-      # Repository
-      repo_field = field_map[:repo] || 'repo'
-      output << sprintf("%-12s%s", "#{repo_field}:", repo) if repo
+      # Type
+      if site_params[:type]
+        type_field = field_map[:type] || 'type'
+        output << sprintf("%-12s%s", "#{type_field}:", site_params[:type])
+      end
       
       # Milestone/Version
       if site_params[:milestone]
@@ -364,6 +388,54 @@ module Issuer
 
     private
 
+    # Wrap a line with proper indentation, handling long lines that exceed terminal width
+    # 
+    # @param line [String] The line to wrap
+    # @param indent_size [Integer] Number of spaces for indentation
+    # @return [Array<String>] Array of wrapped lines with proper indentation
+    # 
+    # @example
+    #   wrap_line_with_indentation("This is a very long line that needs wrapping", 4)
+    #   # => ["    This is a very long line that needs", "    wrapping"]
+    def wrap_line_with_indentation line, indent_size
+      # Get terminal width, default to 80 if not available
+      terminal_width = ENV['COLUMNS']&.to_i || 80
+      
+      # Calculate available width for content (terminal width - indentation)
+      available_width = terminal_width - indent_size
+      
+      # If line fits within available width, just return it with indentation
+      if line.length <= available_width
+        return [' ' * indent_size + line]
+      end
+      
+      # Split long line into chunks that fit
+      wrapped_lines = []
+      remaining_text = line
+      
+      while remaining_text.length > available_width
+        # Find the last space before the available width limit
+        break_point = remaining_text.rindex(' ', available_width)
+        
+        # If no space found, break at the available width (hard wrap)
+        break_point = available_width if break_point.nil?
+        
+        # Extract the chunk and add it with proper indentation
+        chunk = remaining_text[0...break_point]
+        wrapped_lines << (' ' * indent_size + chunk)
+        
+        # Remove the processed chunk from remaining text
+        remaining_text = remaining_text[break_point..].lstrip
+      end
+      
+      # Add the final chunk if any text remains
+      if !remaining_text.empty?
+        wrapped_lines << (' ' * indent_size + remaining_text)
+      end
+      
+      wrapped_lines
+    end
+    
     # Determine if stub logic should be applied to this issue
     # 
     # Checks issue-level stub property first, then falls back to defaults.