superthread 0.7.2

data/lib/superthread/cli/accounts.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Superthread
+  module Cli
+    # CLI commands for managing Superthread accounts.
+    #
+    # Accounts store API credentials and workspace associations. Multiple
+    # accounts can be configured and switched between using these commands.
+    class Accounts < Base
+      desc "list", "List all configured accounts"
+      # Lists all configured accounts with their workspace associations.
+      #
+      # @return [void]
+      def list
+        accounts = app_config.accounts
+
+        if accounts.empty?
+          Ui.warning "No accounts configured"
+          Ui.muted "Run 'suth setup' to add an account"
+          return
+        end
+
+        current = app_config.current_account
+
+        Ui.section "Accounts"
+        accounts.each do |name, _data|
+          state = app_config.account_state(name.to_s)
+          workspace_name = state&.dig(:workspace_name) || state&.dig(:workspace_id) || "(no workspace)"
+          marker = (name.to_s == current) ? "*" : " "
+          puts "  #{marker} #{name.to_s.ljust(15)} #{workspace_name}"
+        end
+        puts ""
+        Ui.muted "Use 'suth account use <name>' to switch accounts"
+      end
+
+      desc "show [NAME]", "Show account details (defaults to current account)"
+      # Displays details for a specific account or the current account.
+      #
+      # @param name [String, nil] account name to show, or nil for current account
+      # @return [void]
+      def show(name = nil)
+        name ||= app_config.current_account
+
+        unless name
+          Ui.warning "No account selected"
+          Ui.muted "Run 'suth setup' to configure an account"
+          return
+        end
+
+        unless app_config.accounts.key?(name.to_sym)
+          Ui.error "Account '#{name}' not found"
+          Ui.muted "Available accounts: #{app_config.accounts.keys.join(", ")}"
+          return
+        end
+
+        account_config = app_config.accounts[name.to_sym]
+        state = app_config.account_state(name)
+        is_current = name == app_config.current_account
+
+        label = is_current ? "Account: #{name} (current)" : "Account: #{name}"
+        Ui.section label
+        puts "  API Key:        #{mask_api_key(account_config&.dig(:api_key))}"
+        puts "  Workspace ID:   #{state&.dig(:workspace_id) || "(not set)"}"
+        puts "  Workspace Name: #{state&.dig(:workspace_name) || "(not set)"}"
+      end
+
+      desc "use NAME", "Switch to a different account"
+      # Switches the active account to the specified account.
+      #
+      # @param name [String] account name to switch to
+      # @return [void]
+      def use(name)
+        unless app_config.accounts.key?(name.to_sym)
+          Ui.error "Account '#{name}' not found"
+          Ui.muted "Available accounts: #{app_config.accounts.keys.join(", ")}"
+          return
+        end
+
+        app_config.current_account = name
+        state = app_config.account_state(name)
+        workspace_name = state&.dig(:workspace_name) || name
+
+        output_success "Switched to account '#{name}' (#{workspace_name})"
+      end
+
+      desc "add NAME", "Add a new account"
+      method_option :with_token, type: :boolean,
+        desc: "Read API key from standard input (for scripts and agents)"
+      method_option :workspace_name, type: :string,
+        desc: "Select workspace by name (non-interactive)"
+      # Adds a new account with API key and workspace selection.
+      #
+      # By default, prompts interactively for the API key. Use --with-token
+      # to read the key from standard input instead (like gh auth login --with-token).
+      #
+      # @param name [String] unique name for the new account
+      # @return [void]
+      def add(name)
+        if app_config.accounts.key?(name.to_sym)
+          Ui.error "Account '#{name}' already exists"
+          Ui.muted "Use 'suth account remove #{name}' first to replace it"
+          return
+        end
+
+        api_key = read_api_key(name)
+        return unless api_key
+
+        # Validate and fetch workspaces
+        begin
+          Ui.spin("Validating API key") do
+            temp_client = Superthread::Client.new(api_key: api_key)
+            @user = temp_client.users.me
+          end
+        rescue Superthread::AuthenticationError
+          Ui.error "Invalid API key"
+          return
+        rescue Superthread::ApiError => e
+          Ui.error "API error: #{e.message}"
+          return
+        end
+
+        teams = @user.teams || []
+        if teams.empty?
+          Ui.error "No workspaces found for this API key"
+          return
+        end
+
+        workspace = select_workspace(teams)
+        return unless workspace
+
+        # Save account
+        app_config.add_account(name, api_key: api_key)
+        app_config.save_account_state(name,
+          workspace_id: workspace.id,
+          workspace_name: workspace.team_name)
+        app_config.set_current_account(name)
+
+        output_success "Account '#{name}' configured (#{workspace.team_name || workspace.id})"
+      end
+
+      desc "remove NAME", "Remove an account"
+      # Removes a configured account after confirmation.
+      #
+      # @param name [String] account name to remove
+      # @return [void]
+      def remove(name)
+        unless app_config.accounts.key?(name.to_sym)
+          Ui.error "Account '#{name}' not found"
+          return
+        end
+
+        confirming("Remove account '#{name}'?") do
+          app_config.remove_account(name)
+          output_success "Account '#{name}' removed"
+
+          if app_config.accounts.empty?
+            Ui.muted "No accounts remaining. Run 'suth setup' to add one."
+          elsif app_config.current_account.nil?
+            first_account = app_config.accounts.keys.first
+            Ui.muted "Tip: Run 'suth account use #{first_account}' to select an account"
+          end
+        end
+      end
+
+      private
+
+      # Reads the API key from stdin (--with-token) or interactive prompt.
+      #
+      # @param account_name [String] the account name (used in interactive prompt)
+      # @return [String, nil] the API key, or nil if empty/missing
+      def read_api_key(account_name)
+        api_key = if options[:with_token]
+          $stdin.gets&.chomp
+        else
+          Ui.password("API key for '#{account_name}'")
+        end
+
+        if api_key.nil? || api_key.empty?
+          if options[:with_token]
+            Ui.error "No API key provided on standard input"
+            Ui.muted "Usage: echo $SUPERTHREAD_API_KEY | suth accounts add NAME --with-token"
+          else
+            Ui.error "API key is required"
+          end
+          return nil
+        end
+
+        api_key
+      end
+
+      # Selects a workspace from the list of teams.
+      #
+      # Uses --workspace-name if provided, auto-selects if only one,
+      # or prompts interactively.
+      #
+      # @param teams [Array] available workspaces
+      # @return [Object, nil] the selected workspace, or nil on error
+      def select_workspace(teams)
+        if teams.length == 1
+          return teams.first
+        end
+
+        if options[:workspace_name]
+          match = teams.find { |t| t.team_name&.downcase == options[:workspace_name].downcase }
+          unless match
+            names = teams.map { |t| t.team_name || t.id }.join(", ")
+            Ui.error "Workspace '#{options[:workspace_name]}' not found"
+            Ui.muted "Available: #{names}"
+            return nil
+          end
+          return match
+        end
+
+        if options[:with_token]
+          Ui.muted "Multiple workspaces found, using '#{teams.first.team_name || teams.first.id}'"
+          Ui.muted "Use --workspace-name to select a different workspace"
+          return teams.first
+        end
+
+        Ui.muted "Found #{teams.length} workspaces:"
+        teams.each_with_index do |team, i|
+          puts "  #{i + 1}. #{team.team_name || team.id}"
+        end
+        choice = Ui.input("Select workspace (1-#{teams.length})")&.to_i || 1
+        teams[choice - 1] || teams.first
+      end
+
+      # Masks an API key for display, showing only the first 4 and last 4 characters.
+      #
+      # @param key [String, nil] the API key to mask
+      # @return [String] the masked key or "(not set)" if nil
+      def mask_api_key(key)
+        return "(not set)" unless key
+        return "***" if key.length < 10
+
+        "#{key[0..3]}...#{key[-4..]}"
+      end
+    end
+  end
+end

data/lib/superthread/cli/activity.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Superthread
+  module Cli
+    # CLI commands for viewing recent activity across the workspace.
+    class Activity < Base
+      include Concerns::DateParsable
+
+      desc "show", "Show recent activity across workspace"
+      option :since, type: :string, default: "today", desc: "Filter by date (e.g., 'friday', '3 days ago')"
+      option :user, type: :string, desc: "Filter by user (ID, name, or 'me')"
+      option :board, type: :string, aliases: "-b", desc: "Filter by board (ID or name)"
+      option :space, type: :string, aliases: "-s", desc: "Space (ID or name) - helps resolve board by name"
+      # Display recent activity across the workspace.
+      #
+      # @return [void]
+      def show
+        handle_error do
+          since_ts = parse_date(options[:since])
+          activity = fetch_activity(since_ts)
+
+          if json_output?
+            output_activity_json(activity)
+          else
+            output_activity_summary(activity, options[:since])
+          end
+        end
+      end
+      default_task :show
+
+      private
+
+      # Fetch all activity data from the workspace.
+      # Returns categorized cards: created, updated, completed.
+      #
+      # @param since_ts [Integer] Unix timestamp for filtering
+      # @return [Hash] Activity data grouped by category
+      def fetch_activity(since_ts)
+        # If user filter specified, use assigned endpoint
+        # Otherwise, we need to get cards differently
+        cards = if options[:user]
+          user_id = resolve_user(options[:user])
+          opts = {user_id: user_id}
+          opts[:board_id] = board_id if options[:board]
+          client.cards.assigned(workspace_id, **opts).to_a
+        elsif options[:board]
+          client.cards.list(workspace_id, board_id: board_id).to_a
+        else
+          # Fetch cards from all boards in the workspace
+          fetch_all_cards
+        end
+
+        categorize_activity(cards, since_ts)
+      end
+
+      # Fetch cards from all boards in the workspace.
+      # This is slower but necessary when no board filter is provided.
+      #
+      # @return [Array<Card>] All cards
+      def fetch_all_cards
+        spaces = client.spaces.list(workspace_id)
+        all_cards = []
+
+        spaces.each do |space|
+          boards = client.boards.list(workspace_id, space_id: space.id)
+          boards.each do |board|
+            cards = client.cards.list(workspace_id, board_id: board.id)
+            all_cards.concat(cards.to_a)
+          rescue Superthread::ApiError
+            # Skip boards we can't access
+          end
+        rescue Superthread::ApiError
+          # Skip spaces we can't access
+        end
+
+        all_cards
+      end
+
+      # Categorize cards into activity buckets based on timestamps.
+      #
+      # @param cards [Array<Card>] the cards to sort into created, updated, and completed buckets
+      # @param since_ts [Integer] Filter timestamp
+      # @return [Hash] Categorized activity
+      def categorize_activity(cards, since_ts)
+        activity = {
+          created: [],
+          updated: [],
+          completed: []
+        }
+
+        cards.each do |card|
+          created_ts = normalize_timestamp(card.time_created)
+          updated_ts = normalize_timestamp(card.time_updated)
+          completed_ts = normalize_timestamp(card.completed_date)
+
+          # Check for completion (takes precedence)
+          if completed_ts && completed_ts >= since_ts
+            activity[:completed] << card
+          # Check for creation
+          elsif created_ts && created_ts >= since_ts
+            activity[:created] << card
+          # Check for update (but not if just created)
+          elsif updated_ts && updated_ts >= since_ts && updated_ts != created_ts
+            activity[:updated] << card
+          end
+        end
+
+        # Sort each category by most recent first
+        activity[:created].sort_by! { |c| -(c.time_created || 0) }
+        activity[:updated].sort_by! { |c| -(c.time_updated || 0) }
+        activity[:completed].sort_by! { |c| -(c.completed_date || 0) }
+
+        activity
+      end
+
+      # Normalize timestamp to seconds (API sometimes returns milliseconds).
+      #
+      # @param ts [Integer, nil] Timestamp
+      # @return [Integer, nil] Normalized timestamp in seconds
+      def normalize_timestamp(ts)
+        Formatter.normalize_timestamp(ts)
+      end
+
+      # Output activity as JSON.
+      #
+      # @param activity [Hash] the categorized activity data with :created, :updated, :completed keys
+      # @return [void]
+      def output_activity_json(activity)
+        json_data = {
+          created: activity[:created].map { |c| card_to_hash(c) },
+          updated: activity[:updated].map { |c| card_to_hash(c) },
+          completed: activity[:completed].map { |c| card_to_hash(c) },
+          summary: {
+            total_created: activity[:created].size,
+            total_updated: activity[:updated].size,
+            total_completed: activity[:completed].size
+          }
+        }
+        puts Formatter.json(json_data)
+      end
+
+      # Convert card to hash for JSON output.
+      #
+      # @param card [Card] the card to convert
+      # @return [Hash] the card data as a hash
+      def card_to_hash(card)
+        {
+          id: card.id,
+          title: card.title,
+          status: card.status,
+          priority: card.priority,
+          list_title: card.list_title,
+          board_title: card.board_title,
+          time_created: card.time_created,
+          time_updated: card.time_updated,
+          completed_date: card.completed_date
+        }
+      end
+
+      # Output activity as a formatted summary.
+      #
+      # @param activity [Hash] the categorized activity data
+      # @param since_label [String] the label describing the time period
+      # @return [void]
+      def output_activity_summary(activity, since_label)
+        total = activity[:created].size + activity[:updated].size + activity[:completed].size
+
+        if total == 0
+          say "No activity since #{since_label}", :yellow
+          return
+        end
+
+        Ui.section "Activity since #{since_label}"
+        puts ""
+
+        if activity[:completed].any?
+          output_activity_section("Completed", activity[:completed], :green)
+        end
+
+        if activity[:created].any?
+          output_activity_section("Created", activity[:created], :cyan)
+        end
+
+        if activity[:updated].any?
+          output_activity_section("Updated", activity[:updated], :yellow)
+        end
+
+        puts ""
+        say "Total: #{total} card(s) (#{activity[:completed].size} completed, " \
+            "#{activity[:created].size} created, #{activity[:updated].size} updated)", :white
+      end
+
+      # Output a section of activity.
+      #
+      # @param label [String] the section header label
+      # @param cards [Array<Card>] the cards to display in this section
+      # @param color [Symbol] the color for the section header
+      # @return [void]
+      def output_activity_section(label, cards, color)
+        say "#{label} (#{cards.size}):", color
+        cards.each do |card|
+          board_info = card.board_title ? " [#{card.board_title}]" : ""
+          list_info = card.list_title ? " -> #{card.list_title}" : ""
+          say "  #{card.id}  #{card.title}#{board_info}#{list_info}"
+        end
+        puts ""
+      end
+    end
+  end
+end