exploremyprofile 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbb95d414e36bede8a58108431a36c0a439a4bb56e92afbf6a62f866021a5a74
-  data.tar.gz: 3e5a41439c7d2e4cb7e640d632aa178731b4dd5ac9a19e872b1aec44982b6cad
+  metadata.gz: cf1d07c5a0807ab5f32cae3a4b3b6baec59accfd1f73d0ee07496861eb7c30ba
+  data.tar.gz: e2f8b53e1454516782505f2e85295e10e061bbe4161f165cf4bae22c44bc48c3
 SHA512:
-  metadata.gz: 7a46d662af6e8926a4d591ed975a748b9c34bc81c3b8567f1a77b274b085d79bb8b4f7555d7ccfa5dc58449884dd6a8b402a90f5aee5b16a546335af506102cc
-  data.tar.gz: e552159bd69ebc39cb17a99c83b2be30fd231ac82fd1cc96f953d3adc742928d158d469da83d328bb4f30699a4365ce2081f08b9ad8bfea6e70a03ffc46d3ca4
+  metadata.gz: 00c11864857331687dd632fbad67499942f8741a8fb873fd4f6948fb01d7fd05d87d309d5de63adc0fce60e57bc3283e56c402cc0f075f309a8223b569b9c537
+  data.tar.gz: 31cc9068c088690e1bd21e1d50f567678363a4c00dcf4cbb77635f8e2db08e6837cef9d05aa2ec41495e3fb4f1f85f180db7ea25aa9b8f8c1ab897f1b53c5645

data/lib/explore/cli/config_store.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Explore
+  module Cli
+    class ConfigStore
+      DEFAULT_RELATIVE_PATH = ".config/explore/credentials.json"
+
+      def initialize(env:, path: nil)
+        @env = env
+        @path = path || env["EXPLORE_CONFIG_PATH"] || default_path
+      end
+
+      def load
+        return {} unless File.file?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError => e
+        raise Error.new("Stored Explore credentials at #{path} are invalid JSON: #{e.message}", exit_code: 1)
+      rescue SystemCallError => e
+        raise Error.new("Could not read stored Explore credentials at #{path}: #{e.message}", exit_code: 1)
+      end
+
+      def save(config)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(config))
+        File.chmod(0o600, path)
+        path
+      rescue SystemCallError => e
+        raise Error.new("Could not save Explore credentials to #{path}: #{e.message}", exit_code: 1)
+      end
+
+      def delete
+        return false unless File.exist?(path)
+
+        File.delete(path)
+        true
+      rescue SystemCallError => e
+        raise Error.new("Could not remove stored Explore credentials at #{path}: #{e.message}", exit_code: 1)
+      end
+
+      attr_reader :path
+
+      private
+
+      attr_reader :env
+
+      def default_path
+        base = env["XDG_CONFIG_HOME"].to_s
+        base = File.join(Dir.home, ".config") if base.empty?
+        File.join(base, "explore", "credentials.json")
+      end
+    end
+  end
+end

data/lib/explore/cli.rb

@@ -2,6 +2,8 @@ require "json"
 require "net/http"
 require "optparse"
 require "uri"
+require "io/console"
+require "explore/profile_document"
 
 module Explore
   module Cli
@@ -38,6 +40,10 @@ module Explore
         request(Net::HTTP::Post, path, params:, json:)
       end
 
+      def put(path, params: {}, json: nil)
+        request(Net::HTTP::Put, path, params:, json:)
+      end
+
       def patch(path, params: {}, json: nil)
         request(Net::HTTP::Patch, path, params:, json:)
       end
@@ -78,20 +84,37 @@ module Explore
       end
 
       def owner_only_unauthorized_message
-        "Unauthorized: this is an owner-only command. Use a signed-in session or pass EXPLORE_API_KEY/--api-key. " \
-          "The key is app-level, not account-specific, and lives in Rails credentials at api.v1_key."
+        "Unauthorized: this is an owner-only command. Use a signed-in session, run explore login --account <slug>, or pass EXPLORE_API_KEY/--api-key. " \
+          "#{owner_token_help_sentence} Then try explore whoami --json."
+      end
+
+      def owner_token_help_sentence
+        if base_url.to_s != ""
+          "Create an account token in the Explore workspace at #{owner_tools_url}."
+        else
+          "Create an account token in the Explore workspace owner tools page (/account/owner-tools)."
+        end
+      rescue URI::InvalidURIError
+        "Create an account token in the Explore workspace owner tools page (/account/owner-tools)."
+      end
+
+      def owner_tools_url
+        URI.join(base_url, "/account/owner-tools").to_s
       end
     end
 
     class Runner
       DEFAULT_BASE_URL = "http://127.0.0.1:3000".freeze
 
-      def initialize(argv:, env:, stdout:, stderr:, client_class: Client)
+      def initialize(argv:, env:, stdout:, stderr:, stdin: $stdin, client_class: Client, config_store: nil, secret_prompt: nil)
         @argv = argv.dup
         @env = env
         @stdout = stdout
         @stderr = stderr
+        @stdin = stdin
         @client_class = client_class
+        @config_store = config_store || ConfigStore.new(env:)
+        @secret_prompt = secret_prompt
       end
 
       def call
@@ -102,10 +125,28 @@ module Explore
         case command
         when "version"
           emit_version
+        when "login"
+          options = parse_options(argv, require_input: false, include_stored: false)
+          validate_whoami_scope!(options)
+          options[:api_key] = resolve_login_api_key!(options)
+          response = client(options).get("/api/agent/v1/profile", params: scope_params(options))
+          saved_path = config_store.save(login_payload(options, response))
+          emit(output_for_login(response, saved_path, options))
+        when "logout"
+          options = parse_options(argv, require_input: false, include_stored: false)
+          removed = config_store.delete
+          emit(output_for_logout(removed, options))
         when "whoami"
           options = parse_options(argv, require_input: false)
+          validate_whoami_scope!(options)
           response = client(options).get("/api/agent/v1/profile", params: scope_params(options))
           emit(output_for_whoami(response, options))
+        when "export"
+          execute_export(argv)
+        when "validate"
+          execute_validate(argv)
+        when "apply"
+          execute_apply(argv)
         when "profile"
           execute_read(argv.shift, "/api/agent/v1/profile")
         when "content"
@@ -143,7 +184,60 @@ module Explore
 
       private
 
-      attr_reader :argv, :env, :stdout, :stderr, :client_class
+      attr_reader :argv, :env, :stdout, :stderr, :stdin, :client_class
+      attr_reader :config_store
+      attr_reader :secret_prompt
+
+      def execute_export(arguments)
+        resource = arguments.shift
+        raise Error.new(usage, exit_code: 2) unless resource == "profile"
+
+        options = parse_options(arguments, require_input: false)
+        format = options.fetch(:format, "yaml")
+        raise Error.new("Only --format yaml is currently supported", exit_code: 2) unless format == "yaml"
+
+        response = client(options).get("/api/agent/v1/profile/document", params: scope_params(options))
+        emit(::Explore::ProfileDocument.dump_yaml(response.fetch("document")))
+        0
+      end
+
+      def execute_validate(arguments)
+        path = arguments.shift
+        raise Error.new(usage, exit_code: 2) if blank_value?(path)
+
+        options = parse_options(arguments, require_input: false)
+        document = ::Explore::ProfileDocument.load_yaml_file(path)
+        result = ::Explore::ProfileDocument.validate(document)
+        emit_validation_result(result, options)
+        result[:ok] ? 0 : 1
+      rescue ::Explore::ProfileDocument::ValidationError => e
+        result = { ok: false, errors: e.errors }
+        emit_validation_result(result, options || { json: false })
+        1
+      end
+
+      def execute_apply(arguments)
+        path = arguments.shift
+        raise Error.new(usage, exit_code: 2) if blank_value?(path)
+
+        options = parse_options(arguments, require_input: false)
+        document = ::Explore::ProfileDocument.load_yaml_file(path)
+        result = ::Explore::ProfileDocument.validate(document)
+        emit_validation_result(result, options) unless result[:ok]
+        return 1 unless result[:ok]
+
+        response = client(options).put(
+          "/api/agent/v1/profile/document",
+          params: scope_params(options),
+          json: { document: result.fetch(:document) }
+        )
+        emit(format_apply_output(response, options))
+        0
+      rescue ::Explore::ProfileDocument::ValidationError => e
+        result = { ok: false, errors: e.errors }
+        emit_validation_result(result, options || { json: false })
+        1
+      end
 
       def execute_read(subcommand, path)
         expected = {
@@ -241,11 +335,12 @@ module Explore
         0
       end
 
-      def parse_options(arguments, require_input:, require_draft_id: false)
+      def parse_options(arguments, require_input:, require_draft_id: false, include_stored: true)
+        stored = include_stored ? config_store.load : {}
         options = {
-          base_url: env.fetch("EXPLORE_BASE_URL", DEFAULT_BASE_URL),
-          api_key: env["EXPLORE_API_KEY"],
-          account: env["EXPLORE_ACCOUNT"],
+          base_url: env["EXPLORE_BASE_URL"] || stored["base_url"] || DEFAULT_BASE_URL,
+          api_key: env["EXPLORE_API_KEY"] || stored["api_key"],
+          account: env["EXPLORE_ACCOUNT"] || stored["account"],
           slug: env["EXPLORE_SLUG"],
           json: false
         }
@@ -253,8 +348,10 @@ module Explore
         parser = OptionParser.new do |opts|
           opts.on("--base-url URL") { |value| options[:base_url] = value }
           opts.on("--api-key TOKEN") { |value| options[:api_key] = value }
+          opts.on("--token-stdin") { options[:token_stdin] = true }
           opts.on("--account ACCOUNT") { |value| options[:account] = value }
           opts.on("--slug SLUG") { |value| options[:slug] = value }
+          opts.on("--format FORMAT") { |value| options[:format] = value }
           opts.on("--draft ID") { |value| options[:draft_id] = value }
           opts.on("--input PATH") { |value| options[:input] = value }
           opts.on("--json") { options[:json] = true }
@@ -271,6 +368,68 @@ module Explore
         client_class.new(base_url: options.fetch(:base_url), api_key: options[:api_key])
       end
 
+      def resolve_login_api_key!(options)
+        return options[:api_key] if present_value?(options[:api_key])
+
+        if options[:token_stdin]
+          token = stdin.read.to_s.strip
+          return token if present_value?(token)
+
+          raise Error.new("No owner token was provided on stdin.", exit_code: 2)
+        end
+
+        token = prompt_for_secret_token
+        return token if present_value?(token)
+
+        raise Error.new(
+          "Missing owner token. Pass --api-key, pipe it with --token-stdin, set EXPLORE_API_KEY, or run explore login interactively in a TTY. " \
+            "#{login_owner_token_help_sentence(options.fetch(:base_url))}",
+          exit_code: 2
+        )
+      end
+
+      def prompt_for_secret_token
+        return secret_prompt.call if secret_prompt
+        return unless stdin.tty? && stdin.respond_to?(:noecho)
+
+        stderr.print("Explore owner token: ")
+        token = stdin.noecho(&:gets).to_s.strip
+        stderr.puts
+        token
+      end
+
+      def login_owner_token_help_sentence(base_url)
+        if base_url.to_s != ""
+          "Create an account token in the Explore workspace at #{login_owner_tools_url(base_url)}."
+        else
+          "Create an account token in the Explore workspace owner tools page (/account/owner-tools)."
+        end
+      rescue URI::InvalidURIError
+        "Create an account token in the Explore workspace owner tools page (/account/owner-tools)."
+      end
+
+      def login_owner_tools_url(base_url)
+        URI.join(base_url, "/account/owner-tools").to_s
+      end
+
+      def login_payload(options, response)
+        {
+          "base_url" => options.fetch(:base_url),
+          "api_key" => options.fetch(:api_key),
+          "account" => options[:account].to_s.empty? ? response.fetch("account_slug") : options.fetch(:account)
+        }
+      end
+
+      def validate_whoami_scope!(options)
+        return unless present_value?(options[:slug])
+
+        raise Error.new(
+          "explore whoami checks owner authentication and does not accept --slug. " \
+            "Use explore profile inspect --slug <slug> for public profile reads.",
+          exit_code: 2
+        )
+      end
+
       def scope_params(options)
         if present_value?(options[:slug])
           { slug: options[:slug] }
@@ -293,6 +452,7 @@ module Explore
         return JSON.pretty_generate(response) if options[:json]
 
         [
+          "Authenticated owner context confirmed.",
           "Account: #{response.dig("profile", "name")}",
           "Slug: #{response["account_slug"]}",
           "Context: #{response.dig("context", "mode")}",
@@ -300,10 +460,44 @@ module Explore
         ].join("\n")
       end
 
+      def output_for_login(response, saved_path, options)
+        payload = {
+          ok: true,
+          account_slug: response.fetch("account_slug"),
+          config_path: saved_path,
+          base_url: options.fetch(:base_url)
+        }
+        return JSON.pretty_generate(payload) if options[:json]
+
+        [
+          "Explore credentials saved.",
+          "Account: #{response.dig("profile", "name")}",
+          "Slug: #{response.fetch("account_slug")}",
+          "Base URL: #{options.fetch(:base_url)}",
+          "Config: #{saved_path}",
+          "Next: run explore whoami --json"
+        ].join("\n")
+      end
+
+      def output_for_logout(removed, options)
+        payload = {
+          ok: true,
+          removed: removed,
+          config_path: config_store.path
+        }
+        return JSON.pretty_generate(payload) if options[:json]
+
+        removed ? "Removed stored Explore credentials from #{config_store.path}." : "No stored Explore credentials found at #{config_store.path}."
+      end
+
       def emit(message)
         stdout.puts(message)
       end
 
+      def emit_validation_result(result, options)
+        emit(format_validation_output(result, options))
+      end
+
       def emit_version
         stdout.puts(Explore::VERSION)
         0
@@ -325,7 +519,12 @@ module Explore
         <<~TEXT
           Usage:
             explore version
-            explore whoami [--account <id-or-slug>] [--slug <slug>] [--json]
+            explore login [--api-key <token> | --token-stdin] [--account <id-or-slug>] [--base-url <url>] [--json]
+            explore logout [--json]
+            explore whoami [--account <id-or-slug>] [--json]
+            explore export profile [--account <id-or-slug>] [--format yaml]
+            explore validate <profile.yaml> [--json]
+            explore apply <profile.yaml> --account <id-or-slug> [--json]
             explore profile inspect [--account <id-or-slug>] [--slug <slug>] [--json]
             explore content list [--account <id-or-slug>] [--slug <slug>] [--json]
             explore content create-draft --account <id-or-slug> --input <file.json> [--json]
@@ -342,6 +541,27 @@ module Explore
             explore content propose-update --account <id-or-slug> --input <file.json> [--json]
         TEXT
       end
+
+      def format_validation_output(result, options)
+        return JSON.pretty_generate(result) if options[:json]
+        return "Profile document is valid." if result[:ok]
+
+        [ "Profile document is invalid:" ] + Array(result[:errors]).map do |entry|
+          "- #{entry.fetch("path")}: #{entry.fetch("message")}"
+        end.join("\n")
+      end
+
+      def format_apply_output(response, options)
+        return JSON.pretty_generate(response) if options[:json]
+
+        counts = response.fetch("applied_counts")
+        [
+          "Applied profile document for #{response.fetch("account_slug")}.",
+          "Projects: #{counts.fetch("projects")}",
+          "Experience: #{counts.fetch("experience")}",
+          "Writing: #{counts.fetch("writing")}"
+        ].join("\n")
+      end
     end
   end
 

data/lib/explore/profile_document.rb

@@ -0,0 +1,280 @@
+require "yaml"
+
+module Explore
+  module ProfileDocument
+    class ValidationError < StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super("Invalid profile document")
+      end
+    end
+
+    module_function
+
+    def from_account(account)
+      {
+        "version" => 1,
+        "profile" => {
+          "name" => account.public_name.to_s,
+          "headline" => account.public_tagline.to_s,
+          "summary" => account.public_bio.to_s,
+          "location" => account.public_location.to_s
+        },
+        "links" => {
+          "email" => account.public_email.to_s,
+          "github_url" => account.public_github_url.to_s,
+          "linkedin_url" => account.public_linkedin_url.to_s,
+          "blog_url" => account.public_blog_url.presence || account.blog_url.to_s,
+          "twitter_url" => account.public_twitter_url.to_s
+        },
+        "projects" => account.account_case_studies.order(:position, :id).map do |project|
+          {
+            "title" => project.title.to_s,
+            "slug" => project.slug.to_s,
+            "summary" => project.summary.to_s,
+            "outcome" => project.outcome.to_s
+          }
+        end,
+        "experience" => account.account_experiences.order(:position, :id).map do |experience|
+          {
+            "company" => experience.company.to_s,
+            "role" => experience.role.to_s,
+            "location" => experience.location.to_s,
+            "start_date" => experience.start_date.to_s,
+            "end_date" => experience.end_date.to_s,
+            "current" => experience.current,
+            "summary" => experience.summary.to_s
+          }
+        end,
+        "writing" => account.account_posts.order(date: :desc, id: :desc).map do |post|
+          {
+            "title" => post.title.to_s,
+            "slug" => post.slug.to_s,
+            "date" => post.date.to_s,
+            "summary" => post.summary.to_s,
+            "url" => post.url.to_s
+          }
+        end
+      }
+    end
+
+    def dump_yaml(document)
+      YAML.dump(document)
+    end
+
+    def load_yaml_file(path)
+      parsed = YAML.safe_load(File.read(path), permitted_classes: [ Date, Time ], aliases: false)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue Psych::SyntaxError => e
+      raise ValidationError.new([ error(path: "$", message: "Malformed YAML: #{e.message.lines.first.to_s.strip}") ])
+    end
+
+    def validate(document)
+      normalized = normalize_hash(document)
+      errors = []
+
+      unless normalized["version"].to_i == 1
+        errors << error(path: "$.version", message: "must be 1")
+      end
+
+      profile = ensure_hash(normalized["profile"])
+      links = ensure_hash(normalized["links"])
+      projects = ensure_array(normalized["projects"])
+      experience = ensure_array(normalized["experience"])
+      writing = ensure_array(normalized["writing"])
+
+      errors.concat(validate_profile(profile))
+      errors.concat(validate_links(links))
+      errors.concat(validate_projects(projects))
+      errors.concat(validate_experience(experience))
+      errors.concat(validate_writing(writing))
+
+      {
+        ok: errors.empty?,
+        document: normalized.merge(
+          "profile" => profile,
+          "links" => links,
+          "projects" => projects,
+          "experience" => experience,
+          "writing" => writing
+        ),
+        errors:
+      }
+    end
+
+    def validate!(document)
+      result = validate(document)
+      raise ValidationError.new(result[:errors]) unless result[:ok]
+
+      result[:document]
+    end
+
+    def error(path:, message:)
+      { "path" => path, "message" => message }
+    end
+
+    def normalize_hash(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(key, nested), memo| memo[key.to_s] = normalize_hash(nested) }
+      when Array
+        value.map { |item| normalize_hash(item) }
+      else
+        value
+      end
+    end
+    private_class_method :normalize_hash
+
+    def ensure_hash(value)
+      value.is_a?(Hash) ? normalize_hash(value) : {}
+    end
+    private_class_method :ensure_hash
+
+    def ensure_array(value)
+      return [] unless value.is_a?(Array)
+
+      value.map { |item| item.is_a?(Hash) ? normalize_hash(item) : item }
+    end
+    private_class_method :ensure_array
+
+    def validate_profile(profile)
+      errors = []
+      %w[name headline summary location].each do |key|
+        errors << error(path: "$.profile.#{key}", message: "must be a string") unless profile[key].is_a?(String)
+      end
+      errors << error(path: "$.profile.name", message: "is required") if profile["name"].to_s.strip.empty?
+      errors << error(path: "$.profile.headline", message: "is required") if profile["headline"].to_s.strip.empty?
+      errors << error(path: "$.profile.summary", message: "is required") if profile["summary"].to_s.strip.empty?
+      errors
+    end
+    private_class_method :validate_profile
+
+    def validate_links(links)
+      errors = []
+      %w[email github_url linkedin_url blog_url twitter_url].each do |key|
+        next if links[key].is_a?(String)
+
+        errors << error(path: "$.links.#{key}", message: "must be a string")
+      end
+
+      %w[github_url linkedin_url blog_url twitter_url].each do |key|
+        next if links[key].to_s.strip.empty?
+        next if http_url?(links[key])
+
+        errors << error(path: "$.links.#{key}", message: "must be a valid http or https URL")
+      end
+
+      if links["email"].present? && links["email"] !~ URI::MailTo::EMAIL_REGEXP
+        errors << error(path: "$.links.email", message: "must be a valid email address")
+      end
+      errors
+    end
+    private_class_method :validate_links
+
+    def validate_projects(projects)
+      validate_collection(projects, "$.projects") do |entry, index, errors|
+        require_string(errors, entry, "$.projects[#{index}].title", "title")
+        require_string(errors, entry, "$.projects[#{index}].slug", "slug")
+        require_string(errors, entry, "$.projects[#{index}].summary", "summary")
+        require_slug(errors, entry["slug"], "$.projects[#{index}].slug")
+      end
+    end
+    private_class_method :validate_projects
+
+    def validate_experience(experience)
+      validate_collection(experience, "$.experience") do |entry, index, errors|
+        require_string(errors, entry, "$.experience[#{index}].company", "company")
+        require_string(errors, entry, "$.experience[#{index}].role", "role")
+        optional_string(errors, entry, "$.experience[#{index}].location", "location")
+        optional_string(errors, entry, "$.experience[#{index}].start_date", "start_date")
+        optional_string(errors, entry, "$.experience[#{index}].end_date", "end_date")
+        optional_string(errors, entry, "$.experience[#{index}].summary", "summary")
+        unless [ true, false ].include?(entry["current"])
+          errors << error(path: "$.experience[#{index}].current", message: "must be true or false")
+        end
+      end
+    end
+    private_class_method :validate_experience
+
+    def validate_writing(writing)
+      validate_collection(writing, "$.writing") do |entry, index, errors|
+        require_string(errors, entry, "$.writing[#{index}].title", "title")
+        require_string(errors, entry, "$.writing[#{index}].slug", "slug")
+        optional_string(errors, entry, "$.writing[#{index}].date", "date")
+        optional_string(errors, entry, "$.writing[#{index}].summary", "summary")
+        optional_string(errors, entry, "$.writing[#{index}].url", "url")
+        require_slug(errors, entry["slug"], "$.writing[#{index}].slug")
+        if entry["url"].present? && !http_url?(entry["url"])
+          errors << error(path: "$.writing[#{index}].url", message: "must be a valid http or https URL")
+        end
+      end
+    end
+    private_class_method :validate_writing
+
+    def validate_collection(collection, path)
+      errors = []
+      unless collection.is_a?(Array)
+        return [ error(path:, message: "must be an array") ]
+      end
+
+      collection.each_with_index do |entry, index|
+        unless entry.is_a?(Hash)
+          errors << error(path: "#{path}[#{index}]", message: "must be an object")
+          next
+        end
+
+        yield(entry, index, errors)
+      end
+
+      errors.concat(duplicate_slug_errors(collection, path))
+      errors
+    end
+    private_class_method :validate_collection
+
+    def duplicate_slug_errors(collection, path)
+      seen = {}
+      collection.each_with_index.filter_map do |entry, index|
+        slug = entry["slug"].to_s.strip
+        next if slug.empty?
+        next unless seen.key?(slug)
+
+        error(path: "#{path}[#{index}].slug", message: "duplicates #{path}[#{seen[slug]}].slug")
+      ensure
+        seen[slug] ||= index unless slug.empty?
+      end
+    end
+    private_class_method :duplicate_slug_errors
+
+    def require_string(errors, entry, path, key)
+      value = entry[key]
+      if !value.is_a?(String)
+        errors << error(path:, message: "must be a string")
+      elsif value.strip.empty?
+        errors << error(path:, message: "is required")
+      end
+    end
+    private_class_method :require_string
+
+    def optional_string(errors, entry, path, key)
+      errors << error(path:, message: "must be a string") unless entry[key].is_a?(String)
+    end
+    private_class_method :optional_string
+
+    def require_slug(errors, value, path)
+      return if value.to_s.match?(/\A[a-z0-9]+(?:-[a-z0-9]+)*\z/)
+
+      errors << error(path:, message: "must use lowercase letters, numbers, and hyphens only")
+    end
+    private_class_method :require_slug
+
+    def http_url?(value)
+      parsed = URI.parse(value.to_s)
+      parsed.is_a?(URI::HTTP) && parsed.host.present?
+    rescue URI::InvalidURIError
+      false
+    end
+    private_class_method :http_url?
+  end
+end

data/lib/explore/version.rb

@@ -2,7 +2,7 @@
 
 module Explore
   module Version
-    STRING = "0.1.0"
+    STRING = "0.1.3"
   end
 
   VERSION = Version::STRING

data/lib/explore.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
 require_relative "explore/version"
+require_relative "explore/cli/config_store"
 require_relative "explore/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exploremyprofile
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - Johnny Butler
@@ -21,6 +21,8 @@ files:
 - exe/explore
 - lib/explore.rb
 - lib/explore/cli.rb
+- lib/explore/cli/config_store.rb
+- lib/explore/profile_document.rb
 - lib/explore/version.rb
 homepage: https://exploremyprofile.com/agent-setup
 licenses: