smily_cli 0.1.0

data/lib/smily_cli/color.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SmilyCli
+  # Minimal, dependency-free ANSI coloring. Coloring is a process-wide setting
+  # (driven by `--no-color`, the `NO_COLOR`/`SMILY_NO_COLOR` env vars, and
+  # whether stdout is a TTY) so formatters can call {Color.bold} etc. without
+  # threading a flag everywhere.
+  module Color
+    CODES = {
+      reset: 0, bold: 1, dim: 2, red: 31, green: 32, yellow: 33,
+      blue: 34, magenta: 35, cyan: 36, gray: 90
+    }.freeze
+
+    class << self
+      # @return [Boolean] whether ANSI codes are currently emitted
+      attr_accessor :enabled
+    end
+
+    # Decide the default enabled state from the environment. Honors the
+    # informal `NO_COLOR` standard and requires an interactive stdout.
+    #
+    # @param stream [IO] stream that output is written to (defaults to $stdout)
+    # @return [Boolean]
+    def self.default_enabled?(stream: $stdout)
+      return false if ENV["NO_COLOR"] && !ENV["NO_COLOR"].empty?
+      return false if ENV["SMILY_NO_COLOR"] && !ENV["SMILY_NO_COLOR"].empty?
+
+      stream.respond_to?(:tty?) && stream.tty?
+    end
+
+    # Wrap `text` in the given ANSI styles when coloring is enabled.
+    #
+    # @param text [String]
+    # @param styles [Array<Symbol>] any of {CODES}' keys
+    # @return [String]
+    def self.paint(text, *styles)
+      return text.to_s unless enabled
+
+      codes = styles.flatten.filter_map { |s| CODES[s] }
+      return text.to_s if codes.empty?
+
+      "\e[#{codes.join(';')}m#{text}\e[0m"
+    end
+
+    CODES.each_key do |name|
+      next if name == :reset
+
+      define_singleton_method(name) { |text| paint(text, name) }
+    end
+  end
+
+  Color.enabled = Color.default_enabled?
+end

data/lib/smily_cli/commands/auth_command.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module SmilyCli
+  module Commands
+    # OAuth helpers: obtain, refresh, inspect and (optionally) persist access
+    # tokens. Client id/secret and refresh token resolve from flags, then env,
+    # then the active profile, so once a profile holds the app credentials the
+    # flags become optional.
+    class AuthCommand < BaseCommand
+      CLIOptions.connection(self)
+      namespace "auth"
+      remove_command "tree"
+
+      desc "client-credentials", "Get an app token via the Client Credentials flow"
+      long_desc <<~DESC
+        Request an application-level access token (public scope, valid ~2h)
+        that can read across every account which authorized the app.
+
+          smily auth client-credentials --client-id ID --client-secret SECRET --save
+      DESC
+      method_option :client_id, type: :string, desc: "Application Client ID (env: SMILY_CLIENT_ID)"
+      method_option :client_secret, type: :string, desc: "Application Client Secret (env: SMILY_CLIENT_SECRET)"
+      method_option :scope, type: :string, desc: "Requested scope(s), space separated"
+      method_option :save, type: :boolean, desc: "Save the token to the active profile"
+      def client_credentials
+        token = context.oauth.client_credentials(
+          client_id: require_option(:client_id, context.client_id, "client id"),
+          client_secret: require_option(:client_secret, context.client_secret, "client secret"),
+          scope: options["scope"]
+        )
+        render_token(token, save_client_id: options["client_id"] || context.client_id,
+                            save_client_secret: options["client_secret"] || context.client_secret)
+      end
+      map "cc" => "client_credentials"
+
+      desc "refresh", "Refresh an access token using a refresh token"
+      method_option :client_id, type: :string, desc: "Application Client ID"
+      method_option :client_secret, type: :string, desc: "Application Client Secret"
+      method_option :refresh_token, type: :string, desc: "Refresh token (env: SMILY_REFRESH_TOKEN)"
+      method_option :redirect_uri, type: :string, desc: "Original redirect URI (if required)"
+      method_option :save, type: :boolean, desc: "Save the new tokens to the active profile"
+      def refresh
+        token = context.oauth.refresh(
+          client_id: require_option(:client_id, context.client_id, "client id"),
+          client_secret: require_option(:client_secret, context.client_secret, "client secret"),
+          refresh_token: require_option(:refresh_token, context.refresh_token, "refresh token"),
+          redirect_uri: options["redirect_uri"]
+        )
+        render_token(token, save_client_id: options["client_id"] || context.client_id,
+                            save_client_secret: options["client_secret"] || context.client_secret)
+      end
+
+      desc "authorize-url", "Print the URL to start the Authorization Code flow"
+      method_option :client_id, type: :string, required: true, desc: "Application Client ID"
+      method_option :redirect_uri, type: :string, required: true, desc: "Registered redirect URI"
+      method_option :scope, type: :string, desc: "Requested scope(s), space separated"
+      method_option :state, type: :string, desc: "Opaque state value"
+      method_option :account_id, type: :string, desc: "Pre-select an account to authorize"
+      method_option :response_type, type: :string, default: "code", desc: "code (server) or token (implicit)"
+      def authorize_url
+        url = context.oauth.authorize_url(
+          client_id: options["client_id"],
+          redirect_uri: options["redirect_uri"],
+          scope: options["scope"],
+          state: options["state"],
+          account_id: options["account_id"],
+          response_type: options["response_type"]
+        )
+        notice("Open this URL, approve the app, then use `smily auth exchange` with the returned code:")
+        emit(url)
+      end
+
+      desc "exchange", "Exchange an authorization code for tokens"
+      method_option :client_id, type: :string, desc: "Application Client ID"
+      method_option :client_secret, type: :string, desc: "Application Client Secret"
+      method_option :code, type: :string, required: true, desc: "Authorization code from the redirect"
+      method_option :redirect_uri, type: :string, required: true, desc: "Same redirect URI as the authorize step"
+      method_option :save, type: :boolean, desc: "Save the tokens to the active profile"
+      def exchange
+        token = context.oauth.authorization_code(
+          client_id: require_option(:client_id, context.client_id, "client id"),
+          client_secret: require_option(:client_secret, context.client_secret, "client secret"),
+          code: options["code"],
+          redirect_uri: options["redirect_uri"]
+        )
+        render_token(token, save_client_id: options["client_id"] || context.client_id,
+                            save_client_secret: options["client_secret"] || context.client_secret)
+      end
+
+      desc "status", "Show whether a token is configured (and optionally validate it)"
+      method_option :check, type: :boolean, desc: "Validate the token against /me"
+      def status
+        token = context.token
+        if token.nil?
+          notice(Color.yellow("No token configured for profile #{context.profile_name.inspect}."))
+          notice("Obtain one with `smily auth client-credentials` or configure it via `smily config set token ...`.")
+          return
+        end
+
+        notice("Profile : #{context.profile_name}")
+        notice("Base URL: #{context.base_url}")
+        notice("Token   : #{mask(token)}")
+        return unless options["check"]
+
+        me = client.me.record || {}
+        account = me["account"] || me["id"]
+        success("Token is valid. Account: #{account}.")
+      end
+
+      desc "token", "Print the resolved access token"
+      def token
+        value = context.token!
+        emit(value)
+      end
+
+      no_commands do
+        # Print a token result, respecting -o json, and optionally persist it.
+        #
+        # Gate the full-payload dump on an *explicitly* requested json format,
+        # not the resolved one: non-TTY output defaults to json, so keying off
+        # {Context#output_format} would spill the whole payload — including the
+        # refresh_token — whenever the token is piped or captured in a command
+        # substitution, defeating token-only scripting. Default stays access
+        # token only; the full payload is opt-in via `-o json` / SMILY_OUTPUT.
+        def render_token(token, save_client_id: nil, save_client_secret: nil)
+          if context.requested_output_format == "json"
+            emit(JSON.pretty_generate(token.raw))
+          else
+            emit(token.access_token)
+            notice(token_summary(token))
+          end
+          save_token(token, save_client_id, save_client_secret) if options["save"]
+        end
+
+        def token_summary(token)
+          parts = []
+          parts << "type=#{token.token_type}" if token.token_type
+          parts << "scope=#{token.scope}" if token.scope
+          parts << "expires_in=#{token.expires_in}s" if token.expires_in
+          parts << "refresh_token=#{mask(token.refresh_token)}" if token.refresh_token
+          Color.dim(parts.join("  "))
+        end
+
+        def save_token(token, client_id, client_secret)
+          cfg = context.config
+          cfg.set("token", token.access_token)
+          cfg.set("base_url", context.base_url)
+          cfg.set("refresh_token", token.refresh_token) if token.refresh_token
+          cfg.set("client_id", client_id) if client_id
+          cfg.set("client_secret", client_secret) if client_secret
+          cfg.save
+          success("Saved token to profile #{cfg.current_profile_name.inspect} (#{cfg.path}).")
+        end
+
+        def require_option(flag, resolved, label)
+          value = options[flag.to_s] || resolved
+          return value if value && !value.to_s.empty?
+
+          raise UsageError, "Missing #{label}: pass --#{flag.to_s.tr('_', '-')} or set it in your profile."
+        end
+
+        def mask(secret)
+          return "" if secret.nil? || secret.empty?
+          return "****" if secret.length <= 4
+
+          "#{'*' * (secret.length - 4)}#{secret[-4, 4]}"
+        end
+      end
+    end
+  end
+end

data/lib/smily_cli/commands/config_command.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module SmilyCli
+  module Commands
+    # Manage the on-disk config file and its profiles. Secrets are masked in any
+    # human-readable listing; the raw file (mode 0600) remains the source of
+    # truth. All subcommands accept `--profile` to target a specific profile.
+    class ConfigCommand < BaseCommand
+      SECRET_KEYS = %w[token refresh_token client_secret mcp_token].freeze
+
+      namespace "config"
+      remove_command "tree"
+      class_option :profile, type: :string, banner: "NAME", desc: "Profile to target"
+      class_option :quiet, type: :boolean, aliases: "-q"
+      class_option :no_color, type: :boolean
+
+      desc "path", "Print the config file path"
+      def path
+        emit(config.path)
+      end
+
+      desc "init", "Create/append a profile interactively"
+      long_desc <<~DESC
+        Initialize a profile by storing a token (and base URL). Values can be
+        passed as flags to run non-interactively:
+
+          smily config init --token TOKEN
+          smily config init --profile staging --base-url https://staging.example.com --token TOKEN
+      DESC
+      method_option :token, type: :string, desc: "Access token to store"
+      method_option :base_url, type: :string, desc: "API base URL to store"
+      def init
+        name = target_profile
+        token = options["token"] || prompt("Access token")
+        base_url = options["base_url"] || prompt("Base URL [https://www.bookingsync.com]", default: Context::DEFAULT_BASE_URL)
+
+        config.set("token", token, profile: name) unless token.to_s.empty?
+        config.set("base_url", base_url, profile: name) unless base_url.to_s.empty?
+        config.current_profile_name = name unless config.profile_names.length > 1 && options["profile"].nil?
+        config.save
+        success("Wrote profile #{name.inspect} to #{config.path}.")
+      end
+
+      desc "list", "List profiles and their settings (secrets masked)"
+      def list
+        if config.profile_names.empty?
+          notice("No profiles configured yet. Create one with `smily config init` or `smily config set`.")
+          return
+        end
+
+        if context_output_json?
+          emit(JSON.pretty_generate(masked_profiles))
+          return
+        end
+
+        lines = config.profile_names.map do |name|
+          marker = name == config.current_profile_name ? Color.green("* ") : "  "
+          settings = masked_profile(name).map { |k, v| "#{k}=#{v}" }.join("  ")
+          "#{marker}#{Color.bold(name)}  #{Color.dim(settings)}"
+        end
+        emit(lines.join("\n"))
+      end
+
+      desc "get KEY", "Print a single setting from the target profile"
+      def get(key)
+        value = config.profile(target_profile)[key]
+        emit(value.nil? ? "" : value.to_s)
+      end
+
+      desc "set KEY VALUE", "Set a setting on the target profile"
+      def set(key, value)
+        warn_unknown_key(key)
+        config.set(key, coerce(value), profile: target_profile)
+        config.save
+        success("Set #{key} on profile #{target_profile.inspect}.")
+      end
+
+      desc "unset KEY", "Remove a setting from the target profile"
+      def unset(key)
+        config.unset(key, profile: target_profile)
+        config.save
+        success("Unset #{key} on profile #{target_profile.inspect}.")
+      end
+
+      desc "use NAME", "Set the default profile"
+      def use(name)
+        unless config.profile?(name)
+          notice(Color.yellow("Profile #{name.inspect} has no settings yet; selecting it anyway."))
+        end
+        config.current_profile_name = name
+        config.save
+        success("Default profile is now #{name.inspect}.")
+      end
+
+      desc "remove NAME", "Delete a profile"
+      method_option :yes, type: :boolean, aliases: "-y"
+      def remove(name)
+        confirm!("Delete profile #{name.inspect}?")
+        config.delete_profile(name)
+        config.save
+        success("Removed profile #{name.inspect}.")
+      end
+
+      no_commands do
+        def config
+          @config ||= Config.load
+        end
+
+        def target_profile
+          options["profile"] || config.current_profile_name
+        end
+
+        def masked_profiles
+          config.profile_names.to_h { |n| [n, masked_profile(n)] }
+        end
+
+        def masked_profile(name)
+          config.profile(name).each_with_object({}) do |(k, v), h|
+            h[k] = SECRET_KEYS.include?(k) ? mask(v.to_s) : v
+          end
+        end
+
+        def context_output_json?
+          fmt = options["output"] || ENV.fetch("SMILY_OUTPUT", nil)
+          fmt.to_s == "json"
+        end
+
+        def warn_unknown_key(key)
+          return if Config::KNOWN_KEYS.include?(key)
+
+          notice(Color.yellow("Note: #{key.inspect} isn't a standard setting (#{Config::KNOWN_KEYS.join(', ')})."))
+        end
+
+        def coerce(value)
+          case value
+          when /\A-?\d+\z/ then value.to_i
+          when "true" then true
+          when "false" then false
+          else value
+          end
+        end
+
+        def prompt(label, default: nil)
+          $stderr.print("#{label}: ")
+          input = $stdin.gets&.strip
+          input = default if input.nil? || input.empty?
+          input
+        end
+
+        def mask(secret)
+          return "" if secret.nil? || secret.empty?
+          return "****" if secret.length <= 4
+
+          "#{'*' * [secret.length - 4, 4].max}#{secret[-4, 4]}"
+        end
+      end
+    end
+  end
+end

data/lib/smily_cli/commands/mcp_command.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module SmilyCli
+  module Commands
+    # `smily mcp` — talk to a BookingSync MCP server (Model Context Protocol)
+    # instead of the REST API. This is a separate mode with its own credential
+    # (`mcp_token`) and endpoint (`mcp_url`, defaulting to `<base-url>/mcp`).
+    #
+    # Two layers:
+    #   * low-level — `tools` (discover) and `call` (invoke) work against any
+    #     MCP server, whatever tools it exposes;
+    #   * convenience — `list` / `get` / `schema` / `resources` mirror the REST
+    #     resource commands, routed through the server's generic dispatcher
+    #     tools, so the mental model carries over.
+    class McpCommand < BaseCommand
+      namespace "mcp"
+      remove_command "tree"
+      CLIOptions.mcp(self)
+      CLIOptions.output(self)
+
+      desc "info", "Handshake with the MCP server and show its capabilities"
+      def info
+        render_payload(mcp_client.connect)
+      end
+
+      desc "tools", "List the tools the MCP server exposes"
+      def tools
+        list = mcp_client.list_tools
+        if context.output_format == "table"
+          rows = list.map { |t| { "name" => t["name"], "description" => t["description"] } }
+          render_result(Result.new(records: rows, single: false))
+        else
+          render_payload(list)
+        end
+      end
+
+      desc "call TOOL", "Call an MCP tool by name with --args JSON"
+      long_desc <<~DESC
+        Invoke any tool the server exposes. Arguments are a JSON object:
+
+          smily mcp call list --args '{"resource":"rentals","limit":5}'
+          smily mcp call resource_schema --args '{"resource":"bookings"}'
+          smily mcp call get --args @args.json
+      DESC
+      method_option :args, type: :string, aliases: "-a", banner: "JSON|@file|-",
+                           desc: "Tool arguments as JSON, @file, or - for stdin"
+      def call(tool)
+        args = options["args"] ? parse_data(options["args"]) : {}
+        render_tool_result(mcp_client.call_tool(tool, args))
+      end
+
+      desc "resources", "List the resources exposed via MCP (generic `resources` tool)"
+      def resources
+        render_tool_result(mcp_client.call_tool(tool_name("resources"), {}))
+      end
+
+      desc "list RESOURCE", "List a resource's records via the MCP `list` tool"
+      long_desc <<~DESC
+        Mirror of `smily <resource> list`, routed through the MCP server:
+
+          smily mcp list rentals --limit 5
+          smily mcp list bookings --filter status=booked --account-id 42
+
+        Filters support the API v3 operator DSL via `attribute[op]=value`
+        (operators: #{SmilyCli::QueryOptions::OPERATORS.join(', ')}). Repeat an
+        attribute to combine conditions (AND), e.g. a range:
+
+          smily mcp list bookings --filter 'final_price[gteq]=600' --filter 'final_price[lt]=800'
+          smily mcp list bookings --filter 'start_at[gt]=2026-01-01T00:00:00Z'
+          smily mcp list bookings --filter 'reference[in]=A123,B456'
+      DESC
+      method_option :filter, type: :array, banner: "k[op]=v", desc: "Attribute filters (supports operators + ranges)"
+      method_option :fields, type: :array, banner: "a b c", desc: "Sparse fieldset"
+      method_option :limit, type: :numeric, aliases: "-n", desc: "Page size"
+      method_option :offset, type: :numeric, desc: "Pagination offset"
+      method_option :ids, type: :string, desc: "Comma-separated ids to fetch"
+      method_option :updated_since, type: :string, desc: "ISO8601 timestamp filter"
+      def list(resource)
+        args = { "resource" => resource }
+        args["filter"] = QueryOptions.parse_filter(options["filter"]) if options["filter"]
+        args["fields"] = context.fields if context.fields
+        args["limit"] = options["limit"] if options["limit"]
+        args["offset"] = options["offset"] if options["offset"]
+        args["ids"] = options["ids"] if options["ids"]
+        args["updated_since"] = options["updated_since"] if options["updated_since"]
+        args.merge!(account_arg)
+        render_tool_result(mcp_client.call_tool(tool_name("list"), args))
+      end
+
+      desc "get RESOURCE ID", "Fetch one record via the MCP `get` tool"
+      method_option :fields, type: :array, banner: "a b c", desc: "Sparse fieldset"
+      def get(resource, id)
+        args = { "resource" => resource, "id" => coerce_id(id) }
+        args["fields"] = context.fields if context.fields
+        args.merge!(account_arg)
+        render_tool_result(mcp_client.call_tool(tool_name("get"), args), single: true)
+      end
+
+      desc "schema RESOURCE", "Show a resource's schema via the MCP `resource_schema` tool"
+      def schema(resource)
+        render_tool_result(mcp_client.call_tool(tool_name("resource_schema"), { "resource" => resource }), single: true)
+      end
+
+      desc "login [TOKEN]", "Save MCP credentials (token, and optional URL) to the active profile"
+      method_option :url, type: :string, desc: "MCP server endpoint to store"
+      def login(token = nil)
+        mcp_token = token || options["mcp_token"]
+        if mcp_token.to_s.empty?
+          raise UsageError, "Provide the MCP token: smily mcp login <TOKEN> (or --mcp-token TOKEN)."
+        end
+
+        cfg = context.config
+        cfg.set("mcp_token", mcp_token)
+        cfg.set("mcp_url", options["url"] || options["mcp_url"]) if options["url"] || options["mcp_url"]
+        cfg.save
+        success("Saved MCP credentials to profile #{cfg.current_profile_name.inspect} (#{cfg.path}).")
+        info_line("Try it with: smily mcp info")
+      end
+
+      no_commands do
+        def mcp_client
+          @mcp_client ||= context.mcp_client
+        end
+
+        # Resolve a convenience verb to an actual tool name, tolerating servers
+        # that prefix their generic tools (e.g. `api_v3_list` vs `list`).
+        def tool_name(base)
+          @tool_names ||= mcp_client.list_tools.map { |t| t["name"] }
+          @tool_names.find { |n| n == base } ||
+            @tool_names.find { |n| n.end_with?("_#{base}", ":#{base}") } ||
+            base
+        end
+
+        def account_arg
+          id = context.account_id
+          id.nil? || id.to_s.empty? ? {} : { "account_id" => coerce_id(id) }
+        end
+
+        def coerce_id(value)
+          value.to_s.match?(/\A\d+\z/) ? value.to_i : value
+        end
+
+        # Render an MCP tool result: raise on `isError`, else render the
+        # structured output (or parsed text content) like any other payload.
+        # `single:` renders a member (e.g. `get`/`schema`) rather than a list.
+        def render_tool_result(result, single: false)
+          raise McpError, tool_text(result) if result["isError"]
+
+          payload = result.key?("structuredContent") ? result["structuredContent"] : parse_text_content(result)
+          render_payload(payload, single: single)
+        end
+
+        def tool_text(result)
+          Array(result["content"]).filter_map { |item| item["text"] }.join("\n")
+        end
+
+        def parse_text_content(result)
+          text = tool_text(result)
+          return text if text.strip.empty?
+
+          JSON.parse(text)
+        rescue JSON::ParserError
+          text
+        end
+
+        # Render an arbitrary payload: a JSON:API envelope becomes a record
+        # table/list; a bare object renders as a single record; a string prints
+        # as-is. `single:` forces member (object) rendering for wrappers like
+        # `get`/`schema`.
+        def render_payload(payload, single: false)
+          case payload
+          when nil then nil
+          when String then emit(payload)
+          when Array then render_result(Result.new(records: payload, single: single))
+          when Hash then render_hash_payload(payload, single: single)
+          else emit(JSON.pretty_generate(payload))
+          end
+        end
+
+        def render_hash_payload(payload, single: false)
+          key = Result.resource_key(payload)
+          if key && payload[key].is_a?(Array)
+            render_result(Result.from_body(payload, single: single))
+          else
+            render_result(Result.new(records: [payload], single: true))
+          end
+        end
+
+        def info_line(message)
+          notice(Color.dim(message))
+        end
+      end
+    end
+  end
+end

data/lib/smily_cli/completion.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SmilyCli
+  # Generates shell completion scripts. The scripts are static (they embed the
+  # known resource and command names at generation time) which keeps completion
+  # instant — no subshell to the CLI on every <Tab>.
+  module Completion
+    SHELLS = %w[bash zsh fish].freeze
+    # Subcommands shared by every resource.
+    RESOURCE_ACTIONS = %w[list get create update delete].freeze
+
+    module_function
+
+    # @param shell [String] one of {SHELLS}
+    # @return [String] the completion script
+    # @raise [UsageError] for an unsupported shell
+    def script(shell)
+      case shell.to_s
+      when "bash" then bash
+      when "zsh"  then zsh
+      when "fish" then fish
+      else
+        raise UsageError, "Unsupported shell #{shell.inspect}. Supported: #{SHELLS.join(', ')}."
+      end
+    end
+
+    # @return [Array<String>] every top-level command word
+    def top_level
+      (Registry.commands + %w[api auth config resources whoami completion version help]).uniq.sort
+    end
+
+    def bash
+      <<~BASH
+        # smily bash completion. Install with:
+        #   smily completion bash > /usr/local/etc/bash_completion.d/smily
+        _smily() {
+          local cur prev words cword
+          _init_completion 2>/dev/null || { cur="${COMP_WORDS[COMP_CWORD]}"; prev="${COMP_WORDS[COMP_CWORD-1]}"; }
+          local top="#{top_level.join(' ')}"
+          local actions="#{RESOURCE_ACTIONS.join(' ')}"
+          if [ "$COMP_CWORD" -eq 1 ]; then
+            COMPREPLY=( $(compgen -W "$top" -- "$cur") )
+          elif [ "$COMP_CWORD" -eq 2 ]; then
+            COMPREPLY=( $(compgen -W "$actions" -- "$cur") )
+          fi
+          return 0
+        }
+        complete -F _smily smily
+      BASH
+    end
+
+    def zsh
+      <<~ZSH
+        #compdef smily
+        # smily zsh completion. Install by placing on your $fpath as _smily, e.g.:
+        #   smily completion zsh > "${fpath[1]}/_smily"
+        _smily() {
+          local -a top actions
+          top=(#{top_level.map { |c| "'#{c}'" }.join(' ')})
+          actions=(#{RESOURCE_ACTIONS.map { |c| "'#{c}'" }.join(' ')})
+          if (( CURRENT == 2 )); then
+            compadd -- $top
+          elif (( CURRENT == 3 )); then
+            compadd -- $actions
+          fi
+        }
+        compdef _smily smily
+      ZSH
+    end
+
+    def fish
+      lines = []
+      lines << "# smily fish completion. Install with:"
+      lines << "#   smily completion fish > ~/.config/fish/completions/smily.fish"
+      lines << "complete -c smily -f"
+      top_level.each do |cmd|
+        lines << "complete -c smily -n '__fish_use_subcommand' -a '#{cmd}'"
+      end
+      RESOURCE_ACTIONS.each do |action|
+        lines << "complete -c smily -n '__fish_seen_subcommand_from #{Registry.commands.join(' ')}' -a '#{action}'"
+      end
+      "#{lines.join("\n")}\n"
+    end
+  end
+end