brandkit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fec24aa78cc7f4ac5dd130e84d05e7fa2d119baef30d403f644ce27d3f36e326
+  data.tar.gz: 444d5f42e748f3c53ffeaa23bde9bc79e2215ea851875869ad81508e45d4cc4a
+SHA512:
+  metadata.gz: 84331e4f351c06029a594164d06cf475275436ed6a09f645c2f35e078d5370250e94503c9d6eaee0af25a9df8c35254c265ef958fb9748d7039d1a049a421cd1
+  data.tar.gz: 7de99fac92531a86570b77f2a5ce6bc60a729fa82c3be069bdfe07a67bb6e48b2e426a44b84daf53526600d8ce85cfcca14d896230d316043570b8afbf6b68df

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rajan Bhattarai
+
+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/README.md

@@ -0,0 +1,164 @@
+# BrandKit
+
+**BrandKit** is a modern, interactive CLI tool designed to help entrepreneurs,
+developers, and creatives quickly check the availability of domains and social
+media usernames — all from the command line. It combines domain availability
+checks via the Namecheap API with username availability checks on popular social
+platforms, helping you secure your brand identity in one place.
+
+---
+
+## Features
+
+- **Domain Availability Check**  
+  Checks if a domain (e.g. `example.com`) is available to register using the
+  Namecheap API. If a domain is not provided with a TLD, it suggests popular
+  extensions like `.com`, `.net`, `.io`, etc., and shows their availability in a
+  table.
+
+- **Social Username Availability Check**  
+  Interactively checks if your chosen username is available on multiple social
+  media platforms including GitHub, Twitter, Instagram, TikTok, LinkedIn, and
+  more.
+
+- **Interactive CLI Experience**  
+  Powered by TTY::Prompt for user-friendly menus, multi-selects, and prompts,
+  plus colorful terminal output for better readability.
+
+- **Clean & Extensible Codebase**  
+  Modular design with dedicated classes for API communication (
+  `NamecheapClient`), domain checks (`DomainChecker`), and social username
+  checks (`SocialUsernameChecker`).
+
+- **Dockerized for Easy Setup**  
+  Runs inside a container for hassle-free installation and dependency
+  management.
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- Ruby 3.x installed locally or use Docker
+- Namecheap API credentials (API user, API key, username, client IP)
+- Internet connection to query domain and social media availability
+
+### Environment Variables
+
+Before running, set these environment variables in your shell or `.env` file:
+
+```bash
+export NAMECHEAP_API_USER=your_api_user
+export NAMECHEAP_API_KEY=your_api_key
+export NAMECHEAP_USERNAME=your_namecheap_username
+export CLIENT_IP=your_client_ip
+```
+
+### Installation
+
+Clone the repo and install dependencies:
+
+```bash
+git clone https://github.com/yourusername/brandkit.git
+cd brandkit
+bundle install
+```
+
+Alternatively, use Docker:
+
+```bash
+docker-compose build
+```
+
+---
+
+## Usage
+
+### Run interactively
+
+Launch the CLI with an interactive prompt experience, guiding you step-by-step:
+
+```bash
+docker-compose run cli
+```
+
+Or locally:
+
+```bash
+ruby bin/brandkit
+```
+
+### Run with command-line arguments
+
+Provide a domain upfront to skip prompts:
+
+```bash
+docker-compose run cli ruby bin/brandkit --domain=example.com
+```
+
+This will check the domain immediately and display availability, with an option
+to check social usernames.
+
+---
+
+## Code Overview
+
+### `BrandKit`
+
+The main CLI application class coordinating user input, output formatting, and
+flow control. Uses:
+
+- `TTY::Prompt` for interactive prompts
+- `Artii` for ASCII banners
+- `Colorize` for colored terminal output
+
+### `DomainChecker`
+
+Handles domain availability checking logic:
+
+- Uses the `NamecheapClient` API wrapper to query domain status
+- Suggests popular TLDs if no extension is provided
+- Displays results in a neat table format
+
+### `ApiClients::NamecheapClient`
+
+API client encapsulating communication with the Namecheap XML API:
+
+- Authenticates via environment variables
+- Handles building query parameters and HTTP requests
+- Parses XML responses and handles errors gracefully
+
+### `SocialUsernameChecker`
+
+Checks username availability on popular social platforms by performing HTTP GET
+requests to profile URLs and interpreting the HTTP response status.
+
+- Supports GitHub, Twitter, Instagram, Facebook, YouTube, TikTok, Pinterest,
+  LinkedIn, Reddit, Threads
+- Allows querying single or multiple platforms interactively
+
+---
+
+## Contributing
+
+Contributions are welcome! Please fork the repo and submit pull requests with
+descriptive commit messages. Make sure to follow the existing code style and add
+tests if applicable.
+
+---
+
+## License
+
+MIT License © Rajan Bhattarai
+
+---
+
+## Acknowledgments
+
+- [Namecheap API](https://www.namecheap.com/support/api/)
+- [TTY Toolkit](https://ttytoolkit.org/)
+- [Artii](https://github.com/miketierney/artii)
+- [Colorize](https://github.com/fazibear/colorize)
+
+---

data/bin/brandkit

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/brand_kit'
+
+BrandKit.new.run

data/lib/api_clients/namecheap_client.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+module ApiClients
+  # A client for interacting with the Namecheap XML API.
+  # Currently supports checking domain availability.
+  class NamecheapClient
+    include HTTParty
+    base_uri 'https://api.namecheap.com/xml.response'
+    
+    attr_reader :api_user, :api_key, :username, :client_ip
+    
+    def initialize
+      @api_user = ENV.fetch('NAMECHEAP_API_USER')
+      @api_key = ENV.fetch('NAMECHEAP_API_KEY')
+      @username = ENV.fetch('NAMECHEAP_USERNAME')
+      @client_ip = ENV.fetch('CLIENT_IP')
+    end
+    
+    # Public: Check if a domain is available for registration.
+    #
+    # domain - A String domain name to check (e.g., "example.com").
+    #
+    # Returns true if the domain is available, false otherwise.
+    def check_domain(domain)
+      response = make_request(
+        command: 'namecheap.domains.check',
+        params: { DomainList: domain }
+      )
+      
+      available = response.dig('ApiResponse', 'CommandResponse', 'DomainCheckResult', 'Available')
+      available == 'true'
+    rescue StandardError => e
+      warn "Error checking domain '#{domain}': #{e.message}"
+      false
+    end
+    
+    private
+    
+    # Private: Build the query parameters for the API call.
+    #
+    # command - Namecheap API command string.
+    # params  - Additional parameters for the specific command.
+    #
+    # Returns a Hash with all query parameters merged.
+    def build_query(command:, params: {})
+      {
+        ApiUser: api_user,
+        ApiKey: api_key,
+        UserName: username,
+        ClientIp: client_ip,
+        Command: command
+      }.merge(params)
+    end
+    
+    # Private: Perform the HTTP GET request to the Namecheap API.
+    #
+    # command - The API command to call (e.g., "namecheap.domains.check").
+    # params  - Additional parameters for the command.
+    #
+    # Returns a parsed Hash of the XML response.
+    def make_request(command:, params: {})
+      query = build_query(command: command, params: params)
+      response = self.class.get('/', query: query)
+      
+      raise "API call failed with HTTP #{response.code}" unless response.success?
+      
+      parsed = response.parsed_response
+      raise 'Invalid API response structure' unless parsed.is_a?(Hash)
+      
+      parsed
+    end
+  end
+end

data/lib/brand_kit.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'byebug'
+require 'tty-prompt'
+require 'tty-table'
+require 'colorize'
+require 'artii'
+require 'dotenv/load'  # this auto-loads .env
+
+require_relative 'domain_checker'
+require_relative 'social_username_checker'
+require_relative 'api_clients/namecheap_client'
+
+# BrandKit CLI app for checking domain and social media username availability
+class BrandKit
+  # Initialize the CLI with prompt, ASCII art generator, and JSON output flag
+  def initialize
+    @prompt = TTY::Prompt.new
+    @artii = Artii::Base.new
+    @json_output = ARGV.include?('--json')
+  end
+  
+  # Main entry point to run the app flow:
+  # 1. Show intro banner
+  # 2. Get domain input from args or prompt
+  # 3. Check domain availability
+  # 4. Show domain result with purchase link if available
+  # 5. Optionally check social username availability
+  # 6. Show farewell banner
+  def run
+    intro_banner
+    
+    domain = extract_domain_from_argv || prompt_for_domain
+    domain_result = DomainChecker.new(domain).check
+    
+    show_result_box(domain_result[:message], :green)
+    
+    print_purchase_link(domain_result) if domain_result[:link]
+    
+    ask_social_check(domain_result[:domain])
+    farewell_banner
+  end
+  
+  private
+  
+  # Extract domain argument from ARGV (e.g. --domain=example.com)
+  #
+  # Returns domain string or nil if not present
+  def extract_domain_from_argv
+    domain_arg = ARGV.find { |arg| arg.start_with?('--domain=') }
+    domain_arg&.split('=', 2)&.last
+  end
+  
+  # Prompt the user for a domain input with colored prompt message
+  #
+  # Returns the user-entered domain string
+  def prompt_for_domain
+    colored_prompt('🌐 Enter domain (e.g. example or example.com):')
+  end
+  
+  # Show ASCII art intro banner with app title and tagline
+  def intro_banner
+    ascii = @artii.asciify('BrandKit').colorize(:cyan)
+    puts ascii
+    
+    width = 60
+    title = '🚀 Welcome to BrandKit'
+    top_border = " #{title.ljust(width - 2)}"
+    bottom_border = '─' * width
+    
+    body = [
+      '',
+      'The fastest way to check domain and',
+      'social media username availability!',
+      ''
+    ].map { |line| line.colorize(:light_white).center(width) }
+    
+    puts top_border
+    body.each { |line| puts line }
+    puts bottom_border
+  end
+  
+  # Show farewell banner with thanks message
+  def farewell_banner
+    width = 60
+    title = '👋'
+    top_border = " #{title.ljust(width - 2)}"
+    bottom_border = '─' * width
+    
+    body = [
+      '',
+      'Thanks for using BrandKit!',
+      'Start building your brand today. ✨',
+      ''
+    ].map { |line| line.colorize(:light_magenta).center(width) }
+    
+    puts top_border
+    body.each { |line| puts line }
+    puts bottom_border
+  end
+  
+  # Display a formatted box with a status message in specified color
+  #
+  # message - String message to display
+  # color   - Symbol colorize color (default :green)
+  def show_result_box(message, color = :green)
+    return if message.to_s.strip.empty?
+    
+    width = 60
+    label = '✦ Domain Status'
+    top_border = " #{label.ljust(width - 2)}"
+    bottom_border = '─' * width
+    
+    body = ['', message.colorize(:light_green).center(width), '']
+    
+    puts "\n"
+    puts top_border.colorize(color)
+    body.each { |line| puts line }
+    puts bottom_border.colorize(color)
+  end
+  
+  # Prompt with colorized question and return the answer
+  #
+  # question - String question to ask user
+  #
+  # Returns user input string
+  def colored_prompt(question)
+    @prompt.ask(question.colorize(:light_blue))
+  end
+  
+  # Print domain purchase link if domain is available
+  #
+  # domain_result - Hash containing domain info (expects :domain key)
+  def print_purchase_link(domain_result)
+    purchase_url = "https://www.namecheap.com/domains/registration/results/?domain=#{domain_result[:domain]}"
+    puts "\n🔗 #{'Purchase here:'.colorize(:light_green)} #{purchase_url.underline}"
+    puts "\n"
+  end
+  
+  # Prompt user whether to check social username availability,
+  # allow selection of platforms, check availability, and print results in a table
+  #
+  # domain - String domain name to check usernames for
+  def ask_social_check(domain)
+    return unless @prompt.yes?('📱 Check if the username is available on social platforms?'.colorize(:light_cyan))
+    
+    all_choice = '🌍 All supported platforms'
+    choices = [all_choice] + SocialUsernameChecker::PLATFORMS.keys.map(&:to_s)
+    
+    selected = prompt_platform_selection(choices, all_choice)
+    
+    platforms_to_check = if selected.include?(all_choice)
+      SocialUsernameChecker::PLATFORMS.keys
+    else
+      selected.map(&:to_sym)
+    end
+    
+    checker = SocialUsernameChecker.new
+    username = checker.send(:strip_extension, domain)
+    
+    results = platforms_to_check.map do |platform|
+      available = checker.username_available?(username, platform)
+      status = available ? '✔ Available'.colorize(:green) : '✘ Taken'.colorize(:red)
+      [platform.to_s.capitalize, status]
+    end
+    
+    table = TTY::Table.new(['📡 Platform', '🔍 Status'], results)
+    puts "\n#{table.render(:unicode, padding: [0, 3], alignment: [:center])}"
+  end
+  
+  # Loop prompting user to select platforms, enforcing selection rules
+  #
+  # choices    - Array of choice strings including 'All supported platforms'
+  # all_choice - String representing 'all platforms' option
+  #
+  # Returns array of selected platform strings
+  def prompt_platform_selection(choices, all_choice)
+    selected = []
+    
+    loop do
+      puts "\n"
+      selected = @prompt.multi_select('✔ Select platforms to check (space to select):'.colorize(:cyan), choices, per_page: 12)
+      
+      if selected.empty?
+        puts '⚠️  You must select at least one platform.'.colorize(:yellow)
+      elsif selected.include?(all_choice) && selected.length > 1
+        puts "⚠️  Please select either '#{all_choice}' or specific platforms, not both.".colorize(:yellow)
+      else
+        break
+      end
+    end
+    
+    selected
+  end
+end

data/lib/domain_checker.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'tty-table'
+require 'colorize'
+
+# DomainChecker handles checking domain availability using Namecheap API.
+# Supports both exact domain check and suggestions with common TLDs.
+class DomainChecker
+  COMMON_TLDS = %w[.com .net .org .io .dev .app .co .xyz .tech .site].freeze
+  
+  # Initialize with the domain string to check.
+  #
+  # domain - String domain or base name (e.g. "example" or "example.com")
+  def initialize(domain)
+    @domain = domain
+    @client = ApiClients::NamecheapClient.new
+  end
+  
+  # Perform the domain availability check.
+  #
+  # Returns a Hash with keys:
+  # - :available (Boolean)
+  # - :domain (String)
+  # - :message (String, colorized)
+  # - :link (String URL if available)
+  # - :suggestions (Array of [domain, available] for common TLDs if no exact domain)
+  def check
+    if exact_domain?(@domain)
+      check_exact_domain(@domain)
+    else
+      check_domain_suggestions(@domain)
+    end
+  end
+  
+  private
+  
+  # Determine if the domain includes a dot (TLD)
+  #
+  # domain - String
+  #
+  # Returns Boolean
+  def exact_domain?(domain)
+    domain.include?('.')
+  end
+  
+  # Check availability for exact domain (with TLD)
+  #
+  # domain - String
+  #
+  # Returns Hash with availability info and message
+  def check_exact_domain(domain)
+    available = @client.check_domain(domain)
+    
+    {
+      available: available,
+      domain: domain,
+      message: available ? success_message(domain) : failure_message(domain),
+      link: available ? purchase_link(domain) : nil
+    }
+  end
+  
+  # Check availability for common TLD suggestions and display results
+  #
+  # base_domain - String domain base without TLD (e.g. "example")
+  #
+  # Returns Hash with message, suggestions, and availability false
+  def check_domain_suggestions(base_domain)
+    suggestions = COMMON_TLDS.map do |tld|
+      full_domain = "#{base_domain}#{tld}"
+      available = @client.check_domain(full_domain)
+      [full_domain, available]
+    end
+    
+    print_suggestions_table(suggestions.first(10))
+    
+    available_count = suggestions.count { |_, available| available }
+    
+    {
+      available: false,
+      domain: base_domain,
+      message: availability_summary_message(base_domain, available_count),
+      suggestions: suggestions
+    }
+  end
+  
+  # Print a formatted table of domain suggestions and their availability
+  #
+  # suggestions - Array of [domain, Boolean availability]
+  def print_suggestions_table(suggestions)
+    rows = suggestions.map do |domain, available|
+      [domain, available ? '✔ Available'.colorize(:green) : '✖ Taken'.colorize(:red)]
+    end
+    
+    table = TTY::Table.new(%w[Domain Status], rows)
+    puts "\nTop Domain Extensions:\n"
+    puts table.render(:unicode, padding: [0, 2])
+  end
+  
+  # Compose a colorized success message for available domain
+  #
+  # domain - String
+  #
+  # Returns String
+  def success_message(domain)
+    "✔ Domain #{domain} is available!".colorize(:green)
+  end
+  
+  # Compose a colorized failure message for taken domain
+  #
+  # domain - String
+  #
+  # Returns String
+  def failure_message(domain)
+    "✘ Domain #{domain} is taken.".colorize(:red)
+  end
+  
+  # Generate a purchase link URL for a domain
+  #
+  # domain - String
+  #
+  # Returns String URL
+  def purchase_link(domain)
+    "https://www.namecheap.com/domains/registration/results/?domain=#{domain}"
+  end
+  
+  # Return a user-friendly message summarizing availability across TLDs
+  #
+  # base_domain    - String base domain (without TLD)
+  # available_count - Integer count of available domains
+  #
+  # Returns String message
+  def availability_summary_message(base_domain, available_count)
+    case available_count
+      when 0
+        "😞 No common domain extensions are available for ‘#{base_domain}’. Try a different name."
+      when 1..3
+        "⚠️ Only a few options are available for ‘#{base_domain}’. Consider securing one quickly!"
+      when 4..6
+        "🙂 Some good domain extensions are still available for ‘#{base_domain}’."
+      else
+        "🎉 Great news! Many domain extensions are available for ‘#{base_domain}’."
+    end
+  end
+end

data/lib/social_username_checker.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'colorize'
+
+# SocialUsernameChecker checks username availability across multiple social platforms.
+class SocialUsernameChecker
+  # Supported platforms and their URL patterns for usernames
+  PLATFORMS = {
+    github: 'https://github.com/%<username>s',
+    twitter: 'https://twitter.com/%<username>s',
+    instagram: 'https://www.instagram.com/%<username>s',
+    facebook: 'https://www.facebook.com/%<username>s',
+    youtube: 'https://www.youtube.com/@%<username>s',
+    tiktok: 'https://www.tiktok.com/@%<username>s',
+    pinterest: 'https://www.pinterest.com/%<username>s',
+    linkedin: 'https://www.linkedin.com/in/%<username>s',
+    reddit: 'https://www.reddit.com/user/%<username>s',
+    threads: 'https://www.threads.net/@%<username>s'
+  }.freeze
+  
+  # Returns an array of supported platform names as strings
+  #
+  # Returns Array<String>
+  def supported_platforms
+    PLATFORMS.keys.map(&:to_s)
+  end
+  
+  # Check if a username is available on a given platform.
+  #
+  # username - String username to check
+  # platform - Symbol or String platform key (e.g., :github or "github")
+  #
+  # Returns Boolean true if available, false if taken or on error.
+  def username_available?(username, platform)
+    platform_key = platform.to_sym
+    
+    unless PLATFORMS.key?(platform_key)
+      warn "Unsupported platform: #{platform}"
+      return false
+    end
+    
+    url = format(PLATFORMS[platform_key], username: username)
+    uri = URI.parse(url)
+    
+    response = fetch_response(uri)
+    
+    # If HTTP status is not 200, assume username is available (profile not found)
+    return true unless response.code == '200'
+    
+    # Check response body for username presence (basic heuristic)
+    body = response.body.force_encoding('UTF-8')
+    
+    # If the username appears in the page content, it's likely taken
+    !body.include?(username)
+  rescue StandardError => e
+    warn "⚠️ Error checking #{platform}: #{e.message}".colorize(:yellow)
+    false
+  end
+  
+  private
+  
+  # Perform a GET request and return the HTTP response
+  #
+  # uri - URI object
+  #
+  # Returns Net::HTTPResponse
+  def fetch_response(uri)
+    Net::HTTP.get_response(uri)
+  end
+  
+  # Remove TLD extension from a domain to get a clean username base
+  #
+  # domain - String domain name (e.g. "example.com")
+  #
+  # Returns String username base (e.g. "example")
+  def strip_extension(domain)
+    domain.split('.').first
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: brandkit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rajan Bhattarai
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: artii
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+description: BrandKit is a Ruby CLI that helps check domain availability via Namecheap
+  API and social media username availability across multiple platforms.
+email:
+- publisher@rajanbhattarai.com
+executables:
+- brandkit
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/brandkit
+- lib/api_clients/namecheap_client.rb
+- lib/brand_kit.rb
+- lib/domain_checker.rb
+- lib/social_username_checker.rb
+homepage: https://github.com/cdrrazan/brandkit
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/cdrrazan/brandkit/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.17
+signing_key:
+specification_version: 4
+summary: A CLI tool to check domain and social username availability
+test_files: []