linear-cli 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6bf813e3a28137493d9fd80024f4cde731f89a52fb493ca03df4d1f9721b375b
+  data.tar.gz: d27e556e89afe79be576ad568232f1e0b9978ce4bb1b4774413d6eabbfeab958
+SHA512:
+  metadata.gz: 4da602c640c58d688a65c281f5380bebb104e2ab5674ec4764dc34fa20b0375c7038fabdf0accd51014c090abfc093fa8638133b157806ad77e9c18674a307a4
+  data.tar.gz: e57503dd7dd5d9328411b67a6b563b522544636606ac94fe7681411c9d9e881641ea1b51c99398dc2823c748c059b17c54d2cf1d676170a50d86d19623fe7244

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-01-24
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Tj (bougyman) Vanderpoel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/Readme.adoc

@@ -0,0 +1,44 @@
+= Linear Command line interface
+:toc: right
+:toclevels: 2
+:sectanchors:
+:icons: font
+:experimental:
+
+A command line interface to https://linear.app.
+
+== Installation
+
+=== From Source
+
+[source,sh]
+----
+$ git clone https://github.com/rubyists/linear-cli.git
+$ cd linear-cli
+$ bundle install
+$ rake install
+----
+
+== Usage
+
+=== Configuration
+
+You must set the LINEAR_API_KEY environment variable to your Linear API key. You can find your API key at https://linear.app/settings/api.
+
+=== Commands
+
+==== Who Am I?
+
+[source,sh]
+----
+$ lc whoami
+$ lc whoami --teams
+----
+
+==== List Issues
+
+[source,sh]
+----
+$ lcls
+$ lcls --full
+----

data/exe/lc

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'linear'
+Rubyists::Linear::L :cli
+Dry::CLI.new(Rubyists::Linear::CLI).call

data/exe/lcls

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+exec File.join(__dir__, 'lcls.sh'), *ARGV

data/exe/lcls.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec lc i ls "$@"

data/lib/linear/api.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'httpx'
+require 'semantic_logger'
+
+module Rubyists
+  module Linear
+    # Responsible for making requests to the Linear API
+    class GraphApi
+      include SemanticLogger::Loggable
+      BASE_URI = 'https://api.linear.app/graphql'
+      RETRY_AFTER = lambda do |*|
+        @retries ||= 0
+        @retries += 1
+        seconds = @retries * 2
+        logger.warn("Retry number #{@retries}, retrying after #{seconds} seconds")
+        seconds
+      end
+
+      def session
+        return @session if @session
+
+        @session = HTTPX.plugin(:retries, retry_after: RETRY_AFTER, max_retries: 5).with(headers:)
+      end
+
+      def headers
+        @headers ||= {
+          'Content-Type' => 'application/json',
+          'Authorization' => api_key
+        }
+      end
+
+      def call(body)
+        res = session.post(BASE_URI, body:)
+        raise SmellsBad, "Bad Response from #{BASE_URI}: #{res}" if res.error
+
+        data = JSON.parse(res.body.read, symbolize_names: true)
+        raise SmellsBad, "No Data Returned for #{body}" unless data&.key?(:data)
+
+        data[:data]
+      end
+
+      def mutation(mutation)
+        q = format('{ "query": "%s" }', mutation.to_s.gsub("\n", '').gsub('"', '\"'))
+        require 'pry' ; binding.pry
+        call q
+      end
+
+      def query(query)
+        call format('{ "query": "%s" }', query.to_s.gsub("\n", '').gsub('"', '\"'))
+      end
+
+      def api_key
+        @api_key ||= ENV.fetch('LINEAR_API_KEY')
+      end
+    end
+    Api = Rubyists::Linear::GraphApi.new
+  end
+end

data/lib/linear/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Linear
+    VERSION = '0.3.3'
+  end
+end

data/lib/linear/cli.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'dry/cli/completion/command'
+require_relative '../linear'
+
+# The Rubyists module is the top-level namespace for all Rubyists projects
+module Rubyists
+  module Linear
+    # The CLI module is a Dry::CLI::Registry that contains all the commands
+    module CLI
+      extend Dry::CLI::Registry
+
+      # Watch for the call method to be added to a command
+      module Watcher
+        def self.extended(_mod)
+          define_method :method_added do |method_name|
+            return unless method_name == :call
+
+            prepend Rubyists::Linear::CLI::Caller
+          end
+        end
+      end
+
+      # The CommonOptions module contains common options for all commands
+      module CommonOptions
+        def self.included(mod)
+          mod.instance_eval do
+            extend Rubyists::Linear::CLI::Watcher
+            option :output, type: :string, default: 'text', values: %w[text json], desc: 'Output format'
+            option :debug, type: :integer, default: 0, desc: 'Debug level'
+          end
+        end
+
+        def display(subject, options)
+          return puts(JSON.pretty_generate(subject)) if options[:output] == 'json'
+          return subject.each { |s| s.display(options) } if subject.respond_to?(:each)
+          unless subject.respond_to?(:display)
+            raise SmellsBad, "Cannot display #{subject}, there is no #display method and it is not a collection"
+          end
+
+          subject.display(options)
+        end
+      end
+
+      # This module is prepended to all commands to log their calls
+      module Caller
+        def self.prepended(_mod) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          Caller.class_eval do
+            define_method :call do |**method_args| # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+              debug = method_args[:debug].to_i
+              Rubyists::Linear.verbosity = debug
+              logger.trace "Calling #{self.class} with #{method_args}"
+              super(**method_args)
+            rescue SmellsBad => e
+              logger.error e.message
+              exit 1
+            rescue NotFoundError => e
+              logger.error e.message
+            rescue StandardError => e
+              logger.error e.message
+              logger.error e.backtrace.join("\n") if Rubyists::Linear.verbosity.positive?
+              exit 5
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Load all our commands
+  Pathname.new(__FILE__).dirname.join('commands').glob('*.rb').each do |file|
+    require file.expand_path
+  end
+
+  module Linear
+    # Open this back up to register 3rd party/other commands
+    module CLI
+      register 'completion', Dry::CLI::Completion::Command[self]
+    end
+  end
+end

data/lib/linear/commands/issue/list.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    M :issue
+    M :user
+    # Namespace for CLI
+    module CLI
+      module Issue
+        List = Class.new Dry::CLI::Command
+        # The List class is a Dry::CLI::Command that lists issues
+        class List
+          include SemanticLogger::Loggable
+          include Rubyists::Linear::CLI::CommonOptions
+
+          option :mine, type: :boolean, default: true, desc: 'Only show my issues'
+          option :unassigned, aliases: ['-u'], type: :boolean, default: false, desc: 'Show unassigned issues only'
+          option :full, type: :boolean, aliases: ['-f'], default: false, desc: 'Show full issue details'
+
+          def call(**options)
+            logger.debug 'Listing issues'
+
+            display issues_for(options), options
+          end
+
+          def issues_for(options)
+            logger.debug('Fetching issues', options:)
+            return Rubyists::Linear::Issue.all(filter: { assignee: { null: true } }) if options[:unassigned]
+            return Rubyists::Linear::User.me.issues if options[:mine]
+
+            Rubyists::Linear::Issue.all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linear/commands/issue/take.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    M :issue, :user
+    # Namespace for CLI
+    module CLI
+      module Issue
+        Take = Class.new Dry::CLI::Command
+        # The Take class is a Dry::CLI::Command that assigns an issue to yourself
+        class Take
+          include SemanticLogger::Loggable
+          include Rubyists::Linear::CLI::CommonOptions
+          desc 'Assign one or more issues to yourself'
+          argument :issue_ids, type: :array, required: true, desc: 'Issue Identifiers'
+
+          def call(issue_ids:, **options) # rubocop:disable Metrics/MethodLength
+            me = Rubyists::Linear::User.me
+            updates = issue_ids.map do |issue_id|
+              issue = Rubyists::Linear::Issue.find(issue_id)
+              logger.debug 'Taking issue', issue:, assignee: me
+              updated = issue.assign! me
+              logger.debug 'Issue taken', issue: updated
+              updated
+            rescue NotFoundError => e
+              logger.error e.message
+              next
+            end.compact
+            display updates, options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linear/commands/issue.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Linear
+    # The Cli module is defined in cli.rb and is the top-level namespace for all CLI commands
+    module CLI
+      # This ALIASES hash will return the key as the value if the key is not found,
+      # otherwise it will return the value of the existing key
+      ALIASES = Hash.new { |h, k| h[k] = k }.merge(
+        'list' => 'ls'
+      )
+
+      Pathname.new(__FILE__).dirname.join('issue').glob('*.rb').each do |file|
+        require file.expand_path
+        register 'issue', aliases: %w[i] do |issue|
+          basename = File.basename(file, '.rb')
+          # The filename is expected to define a class of the same name, but capitalized
+          issue.register ALIASES[basename], Issue.const_get(basename.capitalize)
+        end
+      end
+    end
+  end
+end

data/lib/linear/commands/team/list.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    M :team, :issue
+    # Namespace for CLI
+    module CLI
+      module Team
+        List = Class.new Dry::CLI::Command
+        # The List class is a Dry::CLI::Command that lists issues
+        class List
+          include SemanticLogger::Loggable
+          include Rubyists::Linear::CLI::CommonOptions
+
+          option :mine, type: :boolean, default: true, desc: 'Only show my issues'
+
+          def call(**options)
+            logger.debug 'Listing teams'
+            display teams_for(options), options
+          end
+
+          def teams_for(options)
+            return Rubyists::Linear::Team.mine if options[:mine]
+
+            Rubyists::Linear::Team.all
+          end
+
+          prepend Rubyists::Linear::CLI::Caller
+        end
+      end
+
+      register 'team', aliases: %w[t] do |team|
+        team.register 'ls', Team::List
+      end
+    end
+  end
+end

data/lib/linear/commands/team.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Pathname.new(__FILE__).dirname.join('team').glob('*.rb').each do |file|
+  require file.expand_path
+end

data/lib/linear/commands/whoami.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    M :user
+    # Namespace for CLI
+    module CLI
+      WhoAmI = Class.new Dry::CLI::Command
+      # The WhoAmI command
+      class WhoAmI
+        include SemanticLogger::Loggable
+        include Rubyists::Linear::CLI::CommonOptions
+
+        option :teams, type: :boolean, default: false, desc: 'Show teams'
+
+        def call(**options)
+          logger.debug 'Getting user info'
+          display Rubyists::Linear::User.me(teams: options[:teams]), options
+        end
+
+        prepend Rubyists::Linear::CLI::Caller
+      end
+      register 'whoami', WhoAmI
+    end
+  end
+end

data/lib/linear/exceptions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rubyists
+  module Linear
+    SmellsBad = Class.new(StandardError)
+    NotFoundError = Class.new(StandardError)
+  end
+end

data/lib/linear/fragments.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'gqli'
+
+module Rubyists
+  module Linear
+    # Reusable fragments
+    module Fragments
+      extend GQLi::DSL
+      PageInfo = fragment('PageInfo', 'PageInfo') do
+        pageInfo do
+          hasNextPage
+          endCursor
+        end
+      end
+    end
+  end
+end

data/lib/linear/models/base_model.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'gqli'
+require 'semantic_logger'
+require 'sequel/extensions/inflector'
+
+module Rubyists
+  module Linear
+    # Module which provides a base model for Linear models.
+    class BaseModel
+      extend GQLi::DSL
+      include GQLi::DSL
+      include SemanticLogger::Loggable
+
+      # Methods for Linear models.
+      module MethodMagic
+        def self.included(base) # rubocop:disable Metrics/MethodLength
+          base.instance_eval do
+            base.base_fragment.__nodes.each do |node|
+              sym = node.__name.to_sym
+              define_method node.__name do
+                updated_data[sym]
+              end
+
+              define_method "#{node.__name}=" do |value|
+                updated_data[sym] = value
+              end
+            end
+          end
+        end
+      end
+
+      # Class methods for Linear models.
+      class << self
+        def const_added(const)
+          return unless const == :Base
+
+          include MethodMagic
+        end
+
+        def allq(filter: nil, limit: 50, after: nil)
+          args = { first: limit }
+          args[:filter] = filter ? basic_filter.merge(filter) : basic_filter
+          args.delete(:filter) if args[:filter].empty?
+          args[:after] = after if after
+          all_query args, plural.to_s, base_fragment
+        end
+
+        def all_query(args, subject, base_fragment)
+          query do
+            __node(subject, args) do
+              edges do
+                node { ___ base_fragment }
+                cursor
+              end
+              ___ Fragments::PageInfo
+            end
+          end
+        end
+
+        def just_name
+          name.split('::').last
+        end
+
+        def base_fragment
+          const_get(:Base)
+        end
+
+        def basic_filter
+          return const_get(:BASIC_FILTER) if const_defined?(:BASIC_FILTER)
+
+          {}
+        end
+
+        def plural
+          return const_get(:PLURAL) if const_defined?(:PLURAL)
+
+          just_name.downcase.pluralize.to_sym
+        end
+
+        def gql_query(filter: nil, after: nil)
+          Api.query(allq(filter:, after:))
+        end
+
+        def all(after: nil, filter: nil, max: 100)
+          edges = []
+          moar = true
+          while moar
+            data = gql_query(filter:, after:)
+            subjects = data[plural]
+            edges += subjects[:edges]
+            moar = false if edges.size >= max || !subjects[:pageInfo][:hasNextPage]
+            after = subjects[:pageInfo][:endCursor]
+          end
+          edges.map { |edge| new edge[:node] }
+        end
+      end
+
+      attr_reader :data, :updated_data
+
+      def initialize(data)
+        data.each_key { |k| raise SmellsBad, "Unknown key #{k}" unless respond_to? "#{k}=" }
+        @data = data
+        @updated_data = data.dup
+      end
+
+      def changed?
+        data != updated_data
+      end
+
+      def to_h
+        updated_data
+      end
+
+      def to_json(*_args)
+        updated_data.to_json
+      end
+
+      def inspection
+        format('name: "%<name>s"', name:)
+      end
+
+      def inspect
+        format '#<%<name>s:%<id>s %<inspection>s>', name: self.class.name, id:, inspection:
+      end
+    end
+  end
+end

data/lib/linear/models/issue.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'gqli'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    L :api
+    L :fragments
+    M :base_model
+    M :user
+    Issue = Class.new(BaseModel)
+    # The Issue class represents a Linear issue.
+    class Issue
+      include SemanticLogger::Loggable
+
+      BASIC_FILTER = { completedAt: { null: true } }.freeze
+
+      Base = fragment('BaseIssue', 'Issue') do
+        id
+        identifier
+        title
+        assignee { ___ User::Base }
+        description
+        createdAt
+        updatedAt
+      end
+
+      class << self
+        def find(slug)
+          q = query { issue(id: slug) { ___ Base } }
+          data = Api.query(q)
+          raise NotFoundError, "Issue not found: #{slug}" if data.nil?
+
+          new(data[:issue])
+        end
+      end
+
+      def assign!(user)
+        id_for_this = identifier
+        m = mutation { issueUpdate(id: id_for_this, input: { assigneeId: user.id }) { issue { ___ Base } } }
+        data = Api.query(m)
+        updated = data.dig(:issueUpdate, :issue)
+        raise SmellsBad, "Unknown response for issue update: #{data} (should have :issueUpdate key)" if updated.nil?
+
+        Issue.new updated
+      end
+
+      def inspection
+        format('id: "%<identifier>s" title: "%<title>s"', identifier:, title:)
+      end
+
+      def to_s
+        basic = format('%<id>-12s %<title>s', id: data[:identifier], title: data[:title])
+        return basic unless (name = data.dig(:assignee, :name))
+
+        format('%<basic>s (%<name>s)', basic:, name:)
+      end
+
+      def full
+        sep = '-' * to_s.length
+        format("%<to_s>s\n%<sep>s\n%<description>s\n", sep:, to_s:, description:)
+      end
+
+      def display(options)
+        printf "%s\n", (options[:full] ? full : to_s)
+      end
+    end
+  end
+end

data/lib/linear/models/team.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'gqli'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    L :api, :fragments
+    M :base_model, :issue, :user
+    Team = Class.new(BaseModel)
+    # The Issue class represents a Linear issue.
+    class Team
+      include SemanticLogger::Loggable
+
+      Base = fragment('BaseTeam', 'Team') do
+        description
+        id
+        key
+        name
+        createdAt
+        updatedAt
+      end
+
+      def self.mine
+        User.me.teams
+      end
+
+      def to_s
+        format('%<name>s', name:)
+      end
+
+      def full
+        format('%<key>-6s %<to_s>s', key:, to_s:)
+      end
+
+      def members
+        return @members unless @members.empty?
+
+        q = query do
+          team(id:) do
+            members do
+              nodes { ___ User::Base }
+            end
+          end
+        end
+        data = Api.query(q)
+        @members = data.dig(:team, :members, :nodes)&.map { |member| User.new member } || []
+      end
+
+      def display(_options)
+        printf "%s\n", full
+      end
+    end
+  end
+end

data/lib/linear/models/user.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'gqli'
+
+module Rubyists
+  # Namespace for Linear
+  module Linear
+    L :api
+    M :base_model, :issue, :team
+    User = Class.new(BaseModel)
+    # The User class represents a Linear user.
+    class User
+      include SemanticLogger::Loggable
+
+      Base = fragment('BaseUser', 'User') do
+        id
+        name
+        email
+      end
+
+      WithTeams = fragment('UserWithTeams', 'User') do
+        ___ Base
+        teams do
+          nodes { ___ Team::Base }
+        end
+      end
+
+      def self.me(teams: false)
+        fragment = teams ? WithTeams : Base
+        q = query do
+          viewer do
+            ___ fragment
+          end
+        end
+        data = Api.query(q)
+        new data[:viewer]
+      end
+
+      def initialize(data)
+        super(data)
+        self.teams = data[:teams] if data.key? :teams
+      end
+
+      def issue_query(first)
+        id = data[:id]
+        query do
+          user(id:) do
+            assignedIssues(first:, filter: { completedAt: { null: true } }) do
+              nodes { ___ Issue::Base }
+            end
+          end
+        end
+      end
+
+      def issues(limit: 50)
+        issue_data = Api.query(issue_query(limit))
+        issue_data[:user][:assignedIssues][:nodes].map do |issue|
+          Issue.new issue
+        end
+      end
+
+      def team_query(first)
+        id = data[:id]
+        query do
+          user(id:) do
+            teams(first:) do
+              nodes { ___ Team::Base }
+            end
+          end
+        end
+      end
+
+      def teams=(team_data)
+        team_data.is_a?(Array) && @teams = team_data && return
+
+        if team_data.is_a?(Hash)
+          @teams = team_data[:nodes].map { |team| Team.new team }
+          return
+        end
+
+        raise ArgumentError, "Don't know how to handle #{team_data.class}"
+      end
+
+      def teams(limit: 50)
+        return @teams if @teams
+
+        team_data = Api.query(team_query(limit))
+        @teams = team_data[:user][:teams][:nodes].map do |team|
+          Team.new team
+        end
+      end
+
+      def to_s
+        format('%<id>-20s: %<name>s <%<email>s>', id:, name:, email:)
+      end
+
+      def display(_options)
+        return printf("%s\n", to_s) if @teams.nil?
+
+        printf "%<to_s>s (%<teams>s)\n", to_s:, teams: @teams.map(&:name).join(', ')
+      end
+    end
+  end
+end

data/lib/linear/version.rb

@@ -0,0 +1 @@
+cli/version.rb

data/lib/linear.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'semantic_logger'
+SemanticLogger.default_level = :info
+SemanticLogger.add_appender(io: $stderr, formatter: :color)
+
+# Add the / operator for path separation
+class Pathname
+  def /(other)
+    join(other.to_s)
+  end
+end
+
+module Rubyists
+  # Namespace for Linear classes
+  module Linear
+    include SemanticLogger::Loggable
+    # rubocop:disable Layout/SpaceAroundOperators
+    ROOT = (Pathname(__FILE__)/'../..').expand_path
+    LIBROOT = ROOT/:lib/:linear
+    MODEL_ROOT = ROOT/:lib/:linear/:models
+    SPEC_ROOT = ROOT/:spec
+    FEATURE_ROOT = ROOT/:features
+    DEBUG_LEVELS = %i[warn info debug trace].freeze
+
+    def self.L(*libraries) # rubocop:disable Naming/MethodName
+      Array(libraries).each { |library| require LIBROOT/library }
+    end
+    L :exceptions, :version
+
+    def self.M(*models) # rubocop:disable Naming/MethodName
+      Array(models).each { |model| require MODEL_ROOT/model }
+    end
+    # rubocop:enable Layout/SpaceAroundOperators
+
+    def self.verbosity
+      @verbosity ||= 0
+    end
+
+    def self.verbosity=(debug)
+      return verbosity unless debug
+
+      logger.warn 'Debug level should be between 0 and 3' unless debug.between?(0, 3)
+      @verbosity = debug
+      level = @verbosity > (DEBUG_LEVELS.size - 1) ? :trace : DEBUG_LEVELS[@verbosity]
+      SemanticLogger.default_level = level
+    end
+  end
+end

data/linear-cli.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'lib/linear'
+
+Gem::Specification.new do |spec|
+  spec.name = 'linear-cli'
+  spec.version = Rubyists::Linear::VERSION
+  spec.authors = ['Tj (bougyman) Vanderpoel']
+  spec.email = ['tj@rubyists.com']
+
+  spec.summary = 'CLI for interacting with Linear.app.'
+  spec.description = 'A CLI for interacting with Linear.app. Loosely based on the GitHub CLI'
+  spec.homepage = 'https://github.com/rubyists/linear-cli'
+  spec.required_ruby_version = '>= 3.2.0'
+
+  spec.license = 'MIT'
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[pkg/ bin/ test/ spec/ features/ .git .github appveyor .rspec .rubocop cucumber.yml Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'base64'
+  spec.add_dependency 'dry-cli', '~> 1.0'
+  spec.add_dependency 'dry-cli-completion', '~> 1.0'
+  spec.add_dependency 'gqli', '~> 1.2'
+  spec.add_dependency 'httpx', '~> 1.2'
+  spec.add_dependency 'semantic_logger', '~> 4.0'
+  spec.add_dependency 'sequel'
+  spec.add_dependency 'sqlite3'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/sig/linear/cli.rbs

@@ -0,0 +1,6 @@
+module Linear
+  module Cli
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: linear-cli
+version: !ruby/object:Gem::Version
+  version: 0.3.3
+platform: ruby
+authors:
+- Tj (bougyman) Vanderpoel
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dry-cli-completion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: gqli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: semantic_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A CLI for interacting with Linear.app. Loosely based on the GitHub CLI
+email:
+- tj@rubyists.com
+executables:
+- lc
+- lcls
+- lcls.sh
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- Rakefile
+- Readme.adoc
+- exe/lc
+- exe/lcls
+- exe/lcls.sh
+- lib/linear.rb
+- lib/linear/api.rb
+- lib/linear/cli.rb
+- lib/linear/cli/version.rb
+- lib/linear/commands/issue.rb
+- lib/linear/commands/issue/list.rb
+- lib/linear/commands/issue/take.rb
+- lib/linear/commands/team.rb
+- lib/linear/commands/team/list.rb
+- lib/linear/commands/whoami.rb
+- lib/linear/exceptions.rb
+- lib/linear/fragments.rb
+- lib/linear/models/base_model.rb
+- lib/linear/models/issue.rb
+- lib/linear/models/team.rb
+- lib/linear/models/user.rb
+- lib/linear/version.rb
+- linear-cli.gemspec
+- sig/linear/cli.rbs
+homepage: https://github.com/rubyists/linear-cli
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/rubyists/linear-cli
+  source_code_uri: https://github.com/rubyists/linear-cli
+  changelog_uri: https://github.com/rubyists/linear-cli/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: CLI for interacting with Linear.app.
+test_files: []