shapeup-cli 0.3.2

data/lib/shapeup_cli/commands.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module ShapeupCli
+  module Commands
+    def self.help
+      puts <<~HELP
+        ShapeUp CLI — Manage pitches, scopes, tasks, and cycles from the terminal.
+
+        Usage: shapeup <command> [options]
+
+        Auth:
+          login                     Authenticate via OAuth (creates a profile)
+          logout                    Clear all credentials
+          auth status               Check authentication status
+          auth list                 List configured profiles
+          auth switch <name>        Switch active profile
+          auth remove <name>        Remove a profile
+
+        Discovery:
+          orgs                      List your organisations
+          commands                  List all available commands
+
+        Pitches:
+          pitches list              List pitches (packages)
+          pitches show <id>         Show pitch details with scopes and tasks
+          pitch <id>                Shortcut for pitches show
+
+        Cycles:
+          cycles                    List all cycles
+          cycle show <id>           Show cycle details with pitches and progress
+
+        Scopes:
+          scopes list --pitch <id>  List scopes for a pitch
+          scopes create --pitch <id> "Title"
+          scopes update <id> --title "New title"
+
+        Tasks:
+          tasks list --scope <id>   List tasks for a scope
+          todo "Description" --pitch <id> [--scope <id>]
+          done <id> [<id>...]       Mark task(s) as complete
+
+        Issues:
+          issues                    List open issues
+          issues --all              Include done/closed
+          issues --column triage    Filter by column name
+          issues --assignee me      Issues assigned to me
+          issues --assignee none    Unassigned issues
+          issues --tag seo          Filter by tag
+          issues --stream "Name"    Filter by stream name
+          issues --kind bug         Filter by kind (bug/request)
+          issue <id>                Show issue details
+          issues create "Title" --stream "Name" [--content "..."]
+          issues move <id> --column doing
+          issues done <id>          Mark issue as done
+          issues close <id>         Close issue (won't fix)
+          issues reopen <id>        Reopen a done/closed issue
+          issues icebox <id>        Move to icebox
+          issues defrost <id>       Restore from icebox
+          issues assign <id>        Assign yourself (or --user <id>)
+          issues unassign <id>      Unassign yourself (or --user <id>)
+          issues watch <id>         Watch an issue
+          issues unwatch <id>       Stop watching
+          watching                  List issues you are watching
+          issues delete <id>        Delete an issue
+
+        Comments:
+          comments list --issue <id>           List comments on an issue
+          comments list --pitch <id>           List comments on a pitch
+          comments add --issue <id> "Text"     Add a comment to an issue
+          comments add --pitch <id> "Text"     Add a comment to a pitch
+
+        My Work:
+          my-work, me               Show everything assigned to me
+
+        Search:
+          search "query"            Search across pitches, scopes, tasks, issues
+
+        Config:
+          config show               Show current config
+          config set org "Name"     Set default organisation (name or ID)
+          config set host <url>     Set ShapeUp host
+          config init "Name"        Create .shapeup/config.json for this directory
+
+        Setup:
+          setup claude              Install skill into Claude Code
+          setup cursor              Install skill into Cursor
+          setup project             Install skill into current project
+
+        Output modes (append to any command):
+          --json                    Full JSON envelope with breadcrumbs
+          --md                      Markdown tables
+          --agent                   Raw JSON data only (for AI agents)
+          --quiet, -q               Same as --agent
+          --ids-only                Print only IDs (one per line)
+          (piped output auto-switches to --json)
+
+        Flags:
+          --org <id|name>           Override default organisation
+          --host <url>              Override ShapeUp host (default: https://shapeup.cc)
+
+        Environment variables:
+          SHAPEUP_TOKEN             Bearer token (skips OAuth, for CI/scripts)
+          SHAPEUP_ORG               Default organisation ID
+          SHAPEUP_HOST              API host URL
+
+        Examples:
+          shapeup login
+          shapeup config set org "Compass Labs"
+          shapeup pitches list --json
+          shapeup pitch 42
+          shapeup todo "Fix login bug" --pitch 42 --scope 7
+          shapeup done 123 124 125
+          shapeup me --md
+      HELP
+    end
+
+    def self.list_commands
+      puts <<~COMMANDS
+        login          Authenticate (creates a profile)
+        logout         Clear all credentials
+        auth           Manage profiles (status, list, switch, remove)
+        orgs           List organisations
+        pitches        List/show pitches (list, show)
+        pitch          Show a pitch (shortcut)
+        cycles         List cycles
+        cycle          Show cycle details (list, show)
+        scopes         Manage scopes (list, create, update)
+        tasks          Manage tasks (list, create, complete)
+        todo           Create a task (shortcut)
+        done           Complete task(s) (shortcut)
+        issues         Manage issues (list, show, create, move, icebox, watch)
+        issue          Show an issue (shortcut)
+        watching       List watched issues (shortcut)
+        comments       List and add comments (list, add)
+        my-work / me   Show my assigned work
+        search         Search everything
+        config         Show/set config (set, show, init)
+        setup          Install agent skills (claude, cursor, project)
+        commands       This list
+        help           Usage guide
+        version        Show version
+      COMMANDS
+    end
+  end
+end
+
+require_relative "commands/base"
+require_relative "commands/login"
+require_relative "commands/logout"
+require_relative "commands/orgs"
+require_relative "commands/pitches"
+require_relative "commands/cycle"
+require_relative "commands/scopes"
+require_relative "commands/tasks"
+require_relative "commands/issues"
+require_relative "commands/my_work"
+require_relative "commands/search"
+require_relative "commands/auth"
+require_relative "commands/config_cmd"
+require_relative "commands/setup"
+require_relative "commands/comments"

data/lib/shapeup_cli/config.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module ShapeupCli
+  module Config
+    CONFIG_DIR = File.join(Dir.home, ".config", "shapeup")
+    PROFILES_FILE = File.join(CONFIG_DIR, "profiles.json")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.json")
+
+    # Project-level config — walks up from current directory
+    PROJECT_CONFIG_NAME = ".shapeup/config.json"
+
+    def self.ensure_config_dir
+      FileUtils.mkdir_p(CONFIG_DIR)
+    end
+
+    # --- Profiles ---
+    #
+    # profiles.json stores named profiles:
+    # {
+    #   "default": "compass-labs",
+    #   "profiles": {
+    #     "acme-corp":   { "token": "...", "host": "https://shapeup.cc", "organisation_id": "2", "name": "Acme Corp" },
+    #     "side-project": { "token": "...", "host": "https://shapeup.cc", "organisation_id": "5", "name": "Side Project" }
+    #   }
+    # }
+
+    def self.save_profile(name, token:, host:, organisation_id:, display_name: nil)
+      ensure_config_dir
+      data = load_profiles_raw
+      data["profiles"] ||= {}
+      data["profiles"][name] = {
+        "token" => token,
+        "host" => host,
+        "organisation_id" => organisation_id.to_s,
+        "name" => display_name || name
+      }
+      # Set as default if it's the first profile
+      data["default"] ||= name
+      File.write(PROFILES_FILE, JSON.pretty_generate(data))
+      File.chmod(0600, PROFILES_FILE)
+    end
+
+    def self.switch_profile(name)
+      data = load_profiles_raw
+      unless data.dig("profiles", name)
+        available = (data["profiles"] || {}).keys
+        abort "Profile '#{name}' not found. Available: #{available.join(", ")}"
+      end
+      data["default"] = name
+      File.write(PROFILES_FILE, JSON.pretty_generate(data))
+    end
+
+    def self.delete_profile(name)
+      data = load_profiles_raw
+      data["profiles"]&.delete(name)
+      data["default"] = data["profiles"]&.keys&.first if data["default"] == name
+      File.write(PROFILES_FILE, JSON.pretty_generate(data))
+    end
+
+    def self.list_profiles
+      data = load_profiles_raw
+      default = data["default"]
+      (data["profiles"] || {}).map do |key, profile|
+        { name: key, display_name: profile["name"], organisation_id: profile["organisation_id"],
+          host: profile["host"], default: key == default }
+      end
+    end
+
+    def self.current_profile
+      data = load_profiles_raw
+      name = ENV["SHAPEUP_PROFILE"] || data["default"]
+      return nil unless name
+      profile = data.dig("profiles", name)
+      return nil unless profile
+      profile.merge("profile_name" => name)
+    end
+
+    def self.clear_credentials
+      File.delete(PROFILES_FILE) if File.exist?(PROFILES_FILE)
+    end
+
+    # --- Config (defaults) ---
+
+    def self.save_config(key, value)
+      ensure_config_dir
+      data = load_config_raw
+      data[key] = value
+      File.write(CONFIG_FILE, JSON.pretty_generate(data))
+    end
+
+    def self.load_config
+      data = load_config_raw
+
+      # Merge project-level config (walks up directory tree, takes precedence)
+      if (project_config = find_project_config)
+        project = JSON.parse(File.read(project_config)) rescue {}
+        data.merge!(project)
+      end
+
+      data
+    end
+
+    # Resolution order: env var > project config > global config > profile > default
+    def self.host
+      ENV["SHAPEUP_HOST"] || load_config["host"] || current_profile&.dig("host") || ShapeupCli::DEFAULT_HOST
+    end
+
+    def self.organisation_id
+      ENV["SHAPEUP_ORG"] || load_config["organisation_id"] || current_profile&.dig("organisation_id")&.then { |v| v.empty? ? nil : v }
+    end
+
+    def self.token
+      ENV["SHAPEUP_TOKEN"] || current_profile&.dig("token")
+    end
+
+    # --- Pipe detection ---
+
+    def self.piped?
+      !$stdout.tty?
+    end
+
+    # --- Auth status (for plugin hook) ---
+
+    def self.authenticated?
+      !!token
+    end
+
+    def self.current_profile_name
+      ENV["SHAPEUP_PROFILE"] || load_profiles_raw["default"]
+    end
+
+    private_class_method def self.load_profiles_raw
+      return {} unless File.exist?(PROFILES_FILE)
+      JSON.parse(File.read(PROFILES_FILE)) rescue {}
+    end
+
+    private_class_method def self.load_config_raw
+      return {} unless File.exist?(CONFIG_FILE)
+      JSON.parse(File.read(CONFIG_FILE)) rescue {}
+    end
+
+    # Walk up from current directory looking for .shapeup/config.json
+    private_class_method def self.find_project_config
+      dir = Dir.pwd
+      loop do
+        candidate = File.join(dir, PROJECT_CONFIG_NAME)
+        return candidate if File.exist?(candidate)
+        parent = File.dirname(dir)
+        break if parent == dir # reached root
+        dir = parent
+      end
+      nil
+    end
+  end
+end

data/lib/shapeup_cli/output.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module ShapeupCli
+  module Output
+    # Parse output mode flags from args, returns [mode, remaining_args]
+    def self.parse_mode(args)
+      mode = nil
+      remaining = []
+
+      args.each do |arg|
+        case arg
+        when "--json"  then mode = :json
+        when "--md", "-m" then mode = :markdown
+        when "--agent" then mode = :agent
+        when "--quiet", "-q" then mode = :agent
+        when "--ids-only" then mode = :ids_only
+        else remaining << arg
+        end
+      end
+
+      # Default: auto-detect from TTY. Piped output → JSON, terminal → styled.
+      mode ||= Config.piped? ? :json : :styled
+
+      [ mode, remaining ]
+    end
+
+    # Render a tool result with breadcrumbs in the specified output mode
+    def self.render(result, breadcrumbs: [], mode: :styled, summary: nil)
+      # Extract text content from MCP tool result
+      data = extract_data(result)
+
+      case mode
+      when :json
+        render_json(data, breadcrumbs: breadcrumbs, summary: summary)
+      when :agent
+        render_agent(data)
+      when :markdown
+        render_markdown(data, summary: summary)
+      when :ids_only
+        render_ids_only(data)
+      else
+        render_styled(data, breadcrumbs: breadcrumbs, summary: summary)
+      end
+    end
+
+    def self.extract_data(result)
+      return result unless result.is_a?(Hash)
+
+      # MCP tool results come wrapped: { content: [{ type: "text", text: "..." }] }
+      if result["content"]&.is_a?(Array)
+        text = result["content"].filter_map { |c| c["text"] if c["type"] == "text" }.join
+        JSON.parse(text) rescue text
+      else
+        result
+      end
+    end
+
+    def self.render_json(data, breadcrumbs: [], summary: nil)
+      envelope = { ok: true, data: data }
+      envelope[:summary] = summary if summary
+      envelope[:breadcrumbs] = breadcrumbs if breadcrumbs.any?
+      puts JSON.pretty_generate(envelope)
+    end
+
+    def self.render_agent(data)
+      # Minimal: just the data, no envelope
+      if data.is_a?(String)
+        puts data
+      else
+        puts JSON.generate(data)
+      end
+    end
+
+    def self.render_ids_only(data)
+      items = case data
+      when Array then data
+      when Hash then data.values.find { |v| v.is_a?(Array) } || [ data ]
+      else [ data ]
+      end
+
+      items.each do |item|
+        puts item.is_a?(Hash) ? item["id"] : item
+      end
+    end
+
+    def self.render_markdown(data, summary: nil)
+      puts "**#{summary}**\n" if summary
+
+      case data
+      when Array
+        render_markdown_table(data)
+      when Hash
+        render_markdown_hash(data)
+      else
+        puts data.to_s
+      end
+    end
+
+    def self.render_styled(data, breadcrumbs: [], summary: nil)
+      puts summary if summary
+      puts
+
+      case data
+      when Array
+        render_styled_list(data)
+      when Hash
+        render_styled_hash(data)
+      else
+        puts data.to_s
+      end
+
+      if breadcrumbs.any?
+        puts
+        puts "Next:"
+        breadcrumbs.each do |b|
+          puts "  #{b[:cmd]}  # #{b[:description]}"
+        end
+      end
+    end
+
+    # --- Styled renderers ---
+
+    def self.render_styled_list(items)
+      return puts("  (none)") if items.empty?
+
+      items.each do |item|
+        case item
+        when Hash
+          render_styled_list_item(item)
+        else
+          puts "  #{item}"
+        end
+      end
+    end
+
+    def self.render_styled_list_item(item)
+      # Smart display: detect common fields
+      id = item["id"]
+      title = item["title"] || item["name"] || item["description"]
+      status = item["status"]
+
+      line = "  #{id}"
+      line += "  #{title}" if title
+      line += "  (#{status})" if status
+      puts line
+    end
+
+    def self.render_styled_hash(data)
+      max_key = data.keys.map { |k| k.to_s.length }.max || 0
+
+      data.each do |key, value|
+        label = key.to_s.ljust(max_key)
+        case value
+        when Array
+          puts "  #{label}  (#{value.length} items)"
+          value.first(5).each { |v| puts "    #{format_list_value(v)}" }
+          puts "    ... and #{value.length - 5} more" if value.length > 5
+        when Hash
+          puts "  #{label}  #{format_value(value)}"
+        else
+          puts "  #{label}  #{value}"
+        end
+      end
+    end
+
+    def self.format_value(value)
+      case value
+      when Hash
+        value["title"] || value["name"] || value["description"] || value.to_json
+      else
+        value.to_s
+      end
+    end
+
+    def self.format_list_value(value)
+      case value
+      when Hash
+        id = value["id"]
+        label = value["title"] || value["name"] || value["description"]
+        [id, label].compact.join("  ")
+      else
+        value.to_s
+      end
+    end
+
+    # --- Markdown renderers ---
+
+    def self.render_markdown_table(items)
+      return puts("_No results_") if items.empty?
+      return items.each { |i| puts "- #{i}" } unless items.first.is_a?(Hash)
+
+      keys = items.first.keys.reject { |k| k.is_a?(String) && items.first[k].is_a?(Array) }
+      keys = keys.first(6) # Keep tables readable
+
+      # Header
+      puts "| #{keys.map { |k| k.to_s.gsub("_", " ").capitalize }.join(" | ")} |"
+      puts "| #{keys.map { |_| "---" }.join(" | ")} |"
+
+      # Rows
+      items.each do |item|
+        values = keys.map { |k| truncate(item[k].to_s, 40) }
+        puts "| #{values.join(" | ")} |"
+      end
+    end
+
+    def self.render_markdown_hash(data)
+      data.each do |key, value|
+        case value
+        when Array
+          puts "### #{key.to_s.gsub("_", " ").capitalize} (#{value.length})"
+          render_markdown_table(value)
+          puts
+        when Hash
+          puts "### #{key}"
+          render_markdown_hash(value)
+        else
+          puts "- **#{key}**: #{value}"
+        end
+      end
+    end
+
+    def self.truncate(str, length)
+      str.length > length ? "#{str[0...length - 1]}…" : str
+    end
+
+    private_class_method :render_json, :render_agent, :render_ids_only, :render_markdown, :render_styled,
+      :render_styled_list, :render_styled_list_item, :render_styled_hash,
+      :render_markdown_table, :render_markdown_hash, :format_value, :format_list_value, :truncate
+  end
+end

data/lib/shapeup_cli.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require "fileutils"
+require "securerandom"
+require "digest"
+require "base64"
+require "socket"
+
+require_relative "shapeup_cli/config"
+require_relative "shapeup_cli/auth"
+require_relative "shapeup_cli/client"
+require_relative "shapeup_cli/output"
+require_relative "shapeup_cli/commands"
+
+module ShapeupCli
+  VERSION = "0.3.2"
+  DEFAULT_HOST = "https://shapeup.cc"
+
+  # Exit codes
+  EXIT_OK          = 0
+  EXIT_USAGE       = 1
+  EXIT_NOT_FOUND   = 2
+  EXIT_AUTH         = 3
+  EXIT_PERMISSION  = 4
+  EXIT_API_ERROR   = 5
+  EXIT_RATE_LIMIT  = 6
+  EXIT_INTERRUPTED = 130
+
+  COMMAND_MAP = {
+    "orgs"    => Commands::Orgs,
+    "pitches" => Commands::Pitches,
+    "cycle"   => Commands::Cycle,
+    "scopes"  => Commands::Scopes,
+    "tasks"   => Commands::Tasks,
+    "issues"  => Commands::Issues,
+    "my-work" => Commands::MyWork,
+    "search"  => Commands::Search,
+    "auth"    => Commands::Auth,
+    "config"  => Commands::ConfigCmd,
+    "setup"   => Commands::Setup,
+    "comments" => Commands::Comments
+  }.freeze
+
+  def self.run(argv)
+    args = argv.dup
+
+    # Top-level: shapeup --agent --help
+    if args.include?("--agent") && args.include?("--help")
+      command = (args - [ "--agent", "--help" ]).first
+      if command && COMMAND_MAP[command]
+        puts JSON.pretty_generate(COMMAND_MAP[command].metadata)
+      else
+        puts JSON.pretty_generate(top_level_metadata)
+      end
+      return
+    end
+
+    command = args.shift
+
+    case command
+    when "login"          then Commands::Login.run(args)
+    when "logout"         then Commands::Logout.run(args)
+    when "auth"           then Commands::Auth.run(args)
+    when "orgs"           then Commands::Orgs.run(args)
+    when "pitches"        then Commands::Pitches.run(args)
+    when "pitch"          then Commands::Pitches.run(["show"] + args)
+    when "cycle"          then Commands::Cycle.run(args)
+    when "cycles"         then Commands::Cycle.run(["list"] + args)
+    when "scopes"         then Commands::Scopes.run(args)
+    when "tasks"          then Commands::Tasks.run(args)
+    when "todo"           then Commands::Tasks.run(["create"] + args)
+    when "done"           then Commands::Tasks.run(["complete"] + args)
+    when "issues"         then Commands::Issues.run(args)
+    when "issue"          then Commands::Issues.run(["show"] + args)
+    when "watching"       then Commands::Issues.run(["watching"] + args)
+    when "comments"       then Commands::Comments.run(args)
+    when "my-work", "me"  then Commands::MyWork.run(args)
+    when "search"         then Commands::Search.run(args)
+    when "config"         then Commands::ConfigCmd.run(args)
+    when "setup"          then Commands::Setup.run(args)
+    when "commands"       then Commands.list_commands
+    when "version", "-v", "--version"
+      puts "shapeup #{VERSION}"
+    when "help", "-h", "--help", nil
+      Commands.help
+    else
+      $stderr.puts "Unknown command: #{command}"
+      $stderr.puts "Run 'shapeup help' for usage"
+      exit 1
+    end
+  rescue Client::AuthError => e
+    $stderr.puts "Not authenticated. Run 'shapeup login' first."
+    exit EXIT_AUTH
+  rescue Client::NotFoundError => e
+    $stderr.puts "Not found: #{e.message}"
+    exit EXIT_NOT_FOUND
+  rescue Client::PermissionError => e
+    $stderr.puts "Access denied: #{e.message}"
+    exit EXIT_PERMISSION
+  rescue Client::RateLimitError => e
+    $stderr.puts "Rate limited — please wait and try again."
+    exit EXIT_RATE_LIMIT
+  rescue Client::ApiError => e
+    $stderr.puts "Error: #{e.message}"
+    exit EXIT_API_ERROR
+  rescue Interrupt
+    $stderr.puts "\nAborted."
+    exit EXIT_INTERRUPTED
+  end
+
+  def self.top_level_metadata
+    {
+      command: "shapeup",
+      version: VERSION,
+      short: "Manage ShapeUp pitches, scopes, tasks, issues, and cycles from the terminal",
+      commands: COMMAND_MAP.map { |name, klass| { name: name, **klass.metadata.slice(:short, :path) } },
+      shortcuts: {
+        "pitch <id>" => "pitches show <id>",
+        "cycles" => "cycle list",
+        "todo \"...\"" => "tasks create \"...\"",
+        "done <id>" => "tasks complete <id>",
+        "issue <id>" => "issues show <id>",
+        "watching" => "issues watching",
+        "me" => "my-work"
+      },
+      inherited_flags: [
+        { name: "org", type: "string", usage: "Organisation ID or name" },
+        { name: "json", type: "bool", usage: "Full JSON envelope with breadcrumbs" },
+        { name: "md", type: "bool", usage: "Markdown output" },
+        { name: "agent", type: "bool", usage: "Raw JSON data only (for AI agents)" }
+      ]
+    }
+  end
+end