slidict 0.2.0 → 0.3.1

data/lib/slidict/cli/slides.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Slidict
+  module Cli
+    # Implements the `slidict slides <list|show|create|edit>` subcommands.
+    class Slides
+      def initialize(output:, credentials: nil, client: nil, reauthenticate: nil)
+        @output = output
+        @credentials = credentials || External::SlidictIo::Credentials.new
+        @client = client
+        @reauthenticate = reauthenticate
+      end
+
+      def run(argv)
+        options = parse(argv)
+        return print_help if options[:help] || options[:subcommand].nil?
+
+        send(options[:subcommand], options)
+      rescue ArgumentError => e
+        @output.puts "Error: #{e.message}"
+        @output.puts
+        print_help
+        1
+      end
+
+      # Creates or edits a draft directly, bypassing argv parsing (and its
+      # "looks like a flag" checks, which would reject body text such as
+      # YAML frontmatter that happens to start with "-").
+      def publish(body:, id: nil, title: nil, body_format: nil, visibility: nil)
+        options = { id: id, title: title, body: body, body_format: body_format, visibility: visibility }
+        id ? edit(options) : create(options)
+      end
+
+      private
+
+      def parse(argv)
+        args = argv.dup
+        subcommand = args.shift
+        return { help: true } if subcommand.nil? || %w[-h --help].include?(subcommand)
+
+        case subcommand
+        when "list" then parse_list(args)
+        when "show" then parse_show(args)
+        when "create" then parse_create(args)
+        when "edit" then parse_edit(args)
+        else raise ArgumentError, "unknown slides command #{subcommand}"
+        end
+      end
+
+      def parse_list(args)
+        options = { subcommand: :list }
+        until args.empty?
+          case (arg = args.shift)
+          when "--page" then options[:page] = Integer(fetch_value!(args, arg))
+          when "-h", "--help" then options[:help] = true
+          else raise ArgumentError, "unknown option #{arg}"
+          end
+        end
+        options
+      end
+
+      def parse_show(args)
+        id = args.shift
+        raise ArgumentError, "show requires a slide id" if id.nil?
+        raise ArgumentError, "unknown option #{args.first}" unless args.empty?
+
+        { subcommand: :show, id: id }
+      end
+
+      def parse_create(args)
+        options = { subcommand: :create }
+        parse_body_options!(args, options)
+        options
+      end
+
+      def parse_edit(args)
+        id = args.shift
+        raise ArgumentError, "edit requires a slide id" if id.nil?
+
+        options = { subcommand: :edit, id: id }
+        parse_body_options!(args, options)
+        options
+      end
+
+      def parse_body_options!(args, options)
+        until args.empty?
+          case (arg = args.shift)
+          when "--title" then options[:title] = fetch_value!(args, arg)
+          when "--body" then options[:body] = fetch_value!(args, arg)
+          when "--file" then options[:file] = fetch_value!(args, arg)
+          when "--body-format" then options[:body_format] = fetch_value!(args, arg)
+          when "--visibility" then options[:visibility] = fetch_value!(args, arg)
+          when "-h", "--help" then options[:help] = true
+          else raise ArgumentError, "unknown option #{arg}"
+          end
+        end
+        raise ArgumentError, "specify only one of --body or --file" if options[:body] && options[:file]
+      end
+
+      # Does not reject values starting with "-": body text or titles may
+      # legitimately start with a dash (e.g. YAML frontmatter), and a genuinely
+      # missing value still surfaces as an "unknown option" error from the
+      # next iteration of the parse loop, or a nil check below.
+      def fetch_value!(args, option)
+        value = args.shift
+        raise ArgumentError, "#{option} requires a value" if value.nil?
+
+        value
+      end
+
+      def list(options)
+        with_reauth_retry do
+          print_slide_list(client.list(page: options[:page]))
+          0
+        end
+      end
+
+      def show(options)
+        with_reauth_retry do
+          print_slide_detail(client.show(options[:id]))
+          0
+        rescue External::SlidictIo::Client::NotFound
+          @output.puts "Error: slide not found"
+          1
+        end
+      end
+
+      def create(options)
+        body = read_body(options)
+        raise ArgumentError, "create requires --body or --file" if body.to_s.strip.empty?
+
+        submit("Created") do
+          client.create(title: options[:title], body: body, body_format: options[:body_format],
+                        visibility: options[:visibility])
+        end
+      end
+
+      def edit(options)
+        submit("Updated") do
+          client.update(options[:id], title: options[:title], body: read_body(options),
+                                      body_format: options[:body_format], visibility: options[:visibility])
+        end
+      end
+
+      def submit(verb)
+        with_reauth_retry do
+          slide = yield
+          @output.puts "#{verb} slide ##{slide["id"]} (draft)"
+          print_slide_detail(slide)
+          0
+        rescue External::SlidictIo::Client::NotFound
+          @output.puts "Error: slide not found"
+          1
+        rescue External::SlidictIo::Client::NotEditable
+          @output.puts "Error: this slide is already published. Edit it from the Web UI instead."
+          1
+        rescue External::SlidictIo::Client::RateLimited
+          print_rate_limited
+        rescue External::SlidictIo::Client::Unprocessable => e
+          print_unprocessable(e)
+        end
+      end
+
+      # Shared by list/show/submit: on a 401 from an expired/invalid token,
+      # silently re-authenticate once (via the injected reauthenticate flow)
+      # and retry the same request before giving up.
+      def with_reauth_retry
+        reauthenticated = false
+        begin
+          yield
+        rescue External::SlidictIo::Client::Unauthorized => e
+          if !reauthenticated && reauthenticate!
+            reauthenticated = true
+            retry
+          end
+          print_client_error(e)
+        rescue External::SlidictIo::Client::Error => e
+          print_client_error(e)
+        end
+      end
+
+      def read_body(options)
+        return options[:body] unless options[:file]
+
+        File.read(options[:file])
+      rescue Errno::ENOENT, Errno::EACCES => e
+        raise ArgumentError, "could not read #{options[:file]}: #{e.message}"
+      end
+
+      def client
+        @client ||= begin
+          token = @credentials.read_cli_token
+          token = @credentials.read_cli_token if token.nil? && reauthenticate!
+          raise ArgumentError, "not authenticated. Run `slidict auth` first." unless token
+
+          External::SlidictIo::Client.new(access_token: token[:access_token], token_type: token[:token_type])
+        end
+      end
+
+      # Triggers the injected login flow (see Slidict::Cli::App#auth) and clears the
+      # memoized client so the next call to `client` picks up the fresh token.
+      def reauthenticate!
+        return false unless @reauthenticate
+
+        @client = nil
+        @reauthenticate.call.zero?
+      end
+
+      def print_slide_list(result)
+        slides = result["slides"] || []
+        if slides.empty?
+          @output.puts "No slides found."
+          return
+        end
+
+        slides.each do |slide|
+          @output.puts "##{slide["id"]} [#{slide["status"]}/#{slide["visibility"]}] " \
+                       "#{slide["title"]} (updated_at: #{slide["updated_at"]})"
+        end
+        @output.puts "(more slides available, use --page to see the next page)" if result["has_more"]
+      end
+
+      def print_slide_detail(slide)
+        @output.puts "##{slide["id"]} #{slide["title"]}"
+        @output.puts "status: #{slide["status"]}  visibility: #{slide["visibility"]}  " \
+                     "updated_at: #{slide["updated_at"]}"
+        @output.puts
+        @output.puts slide["body"]
+      end
+
+      def print_rate_limited
+        @output.puts "Error: rate limited. Create/edit is limited to once per minute. Wait and try again."
+        1
+      end
+
+      def print_unprocessable(error)
+        @output.puts "Error: #{error.message}"
+        error.errors.each { |message| @output.puts "  - #{message}" }
+        1
+      end
+
+      def print_client_error(error)
+        @output.puts "Error: #{error.message}"
+        1
+      end
+
+      def print_help
+        @output.puts <<~HELP
+          Usage: slidict slides <command> [options]
+
+          Commands:
+            list [--page N]      List your slides (20 per page)
+            show <id>             Show a slide's details and body
+            create [options]      Create a new draft slide
+            edit <id> [options]   Edit an existing draft slide
+
+          Create/edit options:
+              --title TEXT         Slide title
+              --body TEXT          Slide body text
+              --file PATH          Read the slide body from a file (instead of --body)
+              --body-format FORMAT asciidoc or markdown (default: auto-detected from body)
+              --visibility VIS     public, unlisted, or group_only (default: public)
+          -h, --help                Show this help
+
+          Note: slides are always created/edited as drafts. Publish from the Web UI.
+        HELP
+        0
+      end
+    end
+  end
+end

data/lib/slidict/external/slidict_io/auth.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Slidict
+  module External
+    module SlidictIo
+      class Auth
+        Error = Class.new(StandardError)
+        Pending = Class.new(StandardError)
+
+        DEFAULT_BASE_URL = "https://slidict.io"
+
+        attr_reader :base_url
+
+        def initialize(base_url: ENV.fetch("SLIDICT_AUTH_BASE_URL", DEFAULT_BASE_URL))
+          @base_url = base_url
+        end
+
+        def request_device_code
+          response = post_json("/api/cli/device/code", { provider: "github" })
+          {
+            device_code: fetch!(response, "device_code"),
+            user_code: fetch!(response, "user_code"),
+            verification_uri: response["verification_uri"] || "#{base_url}/cli/activate",
+            interval: response.fetch("interval", 5).to_i,
+            expires_in: response.fetch("expires_in", 600).to_i
+          }
+        end
+
+        def poll_token(device_code:)
+          response = post_json(
+            "/api/cli/device/token",
+            { device_code: device_code, grant_type: "urn:ietf:params:oauth:grant-type:device_code" },
+            raise_on_http_error: false
+          )
+          return response if response["access_token"]
+
+          error = response["error"].to_s
+          raise Pending if %w[authorization_pending slow_down].include?(error)
+
+          raise Error, response["error_description"] || error unless error.empty?
+
+          raise Error, "token response did not include access_token"
+        end
+
+        private
+
+        def post_json(path, payload, raise_on_http_error: true)
+          uri = URI.join(base_url, path)
+          request = Net::HTTP::Post.new(uri)
+          request["Accept"] = "application/json"
+          request["Content-Type"] = "application/json"
+          request.body = JSON.generate(payload)
+
+          response = Net::HTTP.start(uri.hostname, uri.port,
+                                     use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 30) do |http|
+            http.request(request)
+          end
+          body = response.body.to_s.empty? ? {} : JSON.parse(response.body)
+          return body if response.is_a?(Net::HTTPSuccess) || !raise_on_http_error
+
+          raise Error, body["error_description"] || body["error"] || "HTTP #{response.code}"
+        rescue JSON::ParserError => e
+          raise Error, "invalid JSON response: #{e.message}"
+        rescue SystemCallError, Timeout::Error => e
+          raise Error, e.message
+        end
+
+        def fetch!(hash, key)
+          hash.fetch(key)
+        rescue KeyError
+          raise Error, "device code response did not include #{key}"
+        end
+      end
+    end
+  end
+end

data/lib/slidict/external/slidict_io/client.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Slidict
+  module External
+    module SlidictIo
+      # Talks to the slidict.io CLI slides API using a CLI access token
+      # (obtained via Slidict::External::SlidictIo::Auth / `slidict auth`).
+      class Client
+        class Error < StandardError; end
+        class Unauthorized < Error; end
+        class Forbidden < Error; end
+        class NotFound < Error; end
+        class NotEditable < Error; end
+        class RateLimited < Error; end
+
+        # Raised for 422 responses other than "not_editable", carrying the API's validation errors.
+        class Unprocessable < Error
+          attr_reader :errors
+
+          def initialize(message, errors: [])
+            super(message)
+            @errors = errors
+          end
+        end
+
+        DEFAULT_BASE_URL = "https://slidict.io"
+
+        attr_reader :base_url
+
+        def initialize(access_token:, token_type: "Bearer",
+                       base_url: ENV.fetch("SLIDICT_AUTH_BASE_URL", DEFAULT_BASE_URL))
+          @access_token = access_token
+          @token_type = token_type
+          @base_url = base_url
+        end
+
+        def list(page: nil)
+          get_json("/api/cli/slides", query: page ? { page: page } : {})
+        end
+
+        def show(id)
+          get_json("/api/cli/slides/#{id}")
+        end
+
+        def create(body:, title: nil, body_format: nil, visibility: nil)
+          post_json("/api/cli/slides",
+                    slide_payload(title: title, body: body, body_format: body_format, visibility: visibility))
+        end
+
+        def update(id, body: nil, title: nil, body_format: nil, visibility: nil)
+          patch_json("/api/cli/slides/#{id}",
+                     slide_payload(title: title, body: body, body_format: body_format, visibility: visibility))
+        end
+
+        private
+
+        def slide_payload(title:, body:, body_format:, visibility:)
+          { title: title, body: body, body_format: body_format, visibility: visibility }.compact
+        end
+
+        def get_json(path, query: {})
+          uri = URI.join(base_url, path)
+          uri.query = URI.encode_www_form(query) unless query.empty?
+          perform(uri, Net::HTTP::Get.new(uri))
+        end
+
+        def post_json(path, payload)
+          uri = URI.join(base_url, path)
+          perform(uri, build_request(Net::HTTP::Post.new(uri), payload))
+        end
+
+        def patch_json(path, payload)
+          uri = URI.join(base_url, path)
+          perform(uri, build_request(Net::HTTP::Patch.new(uri), payload))
+        end
+
+        def build_request(request, payload)
+          request["Content-Type"] = "application/json"
+          request.body = JSON.generate(payload)
+          request
+        end
+
+        def perform(uri, request)
+          request["Accept"] = "application/json"
+          request["Authorization"] = "#{@token_type} #{@access_token}"
+
+          response = Net::HTTP.start(uri.hostname, uri.port,
+                                     use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 30) do |http|
+            http.request(request)
+          end
+          body = response.body.to_s.empty? ? {} : JSON.parse(response.body)
+          handle_response(response, body)
+        rescue JSON::ParserError => e
+          raise Error, "invalid JSON response: #{e.message}"
+        rescue SystemCallError, Timeout::Error => e
+          raise Error, e.message
+        end
+
+        ERROR_CLASSES_BY_STATUS = {
+          "401" => Unauthorized,
+          "403" => Forbidden,
+          "404" => NotFound,
+          "429" => RateLimited
+        }.freeze
+
+        def handle_response(response, body)
+          return body if response.is_a?(Net::HTTPSuccess)
+          return raise_unprocessable(body) if response.code == "422"
+
+          error_class = ERROR_CLASSES_BY_STATUS.fetch(response.code, Error)
+          raise error_class, body["error_description"] || body["error"] || "HTTP #{response.code}"
+        end
+
+        def raise_unprocessable(body)
+          raise NotEditable, "not_editable" if body["error"] == "not_editable"
+
+          raise Unprocessable.new(body["error"] || "unprocessable", errors: Array(body["errors"]))
+        end
+      end
+    end
+  end
+end

data/lib/slidict/external/slidict_io/credentials.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Slidict
+  module External
+    module SlidictIo
+      class Credentials
+        DEFAULT_PATH = File.expand_path("~/.config/slidict/credentials.json")
+
+        def initialize(path: DEFAULT_PATH)
+          @path = path
+        end
+
+        def write_cli_token!(access_token:, token_type: "Bearer", provider: "github")
+          FileUtils.mkdir_p(File.dirname(@path), mode: 0o700)
+          json = JSON.pretty_generate(
+            "access_token" => access_token,
+            "token_type" => token_type,
+            "provider" => provider,
+            "kind" => "cli_access_token"
+          )
+          File.write(@path, "#{json}\n", mode: "w", perm: 0o600)
+          File.chmod(0o600, @path)
+          @path
+        end
+
+        # Returns { access_token:, token_type: } or nil if no CLI access token is saved.
+        def read_cli_token
+          return nil unless File.exist?(@path)
+
+          data = JSON.parse(File.read(@path))
+          return nil unless data["kind"] == "cli_access_token" && data["access_token"]
+
+          { access_token: data["access_token"], token_type: data.fetch("token_type", "Bearer") }
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/slidict/llm/client.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Slidict
+  module Llm
+    # Talks to any OpenAI Compatible API (OpenAI, Ollama, LM Studio, vLLM, etc.)
+    # via the standard /chat/completions endpoint. Configure the target with
+    # Slidict::Config (base_url, api_key, model).
+    class Client
+      class Error < StandardError; end
+
+      def initialize(base_url:, api_key:, model:)
+        @base_url = base_url
+        @api_key = api_key
+        @model = model
+      end
+
+      # Checks that the endpoint is reachable before the (slower, more
+      # expensive) chat completion request is made. Raises Error on failure.
+      def verify_connection!
+        uri = endpoint_uri("models")
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Bearer #{@api_key}"
+        response = perform_request(uri, request)
+
+        raise Error, "#{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+      end
+
+      def generate_slides(deck)
+        content = chat_completion(prompt_for(deck))
+        slides_from(content)
+      end
+
+      private
+
+      def prompt_for(deck)
+        <<~PROMPT
+          You are an assistant that designs presentation slide outlines.
+          Topic: #{deck.topic}
+          Duration: #{deck.duration}
+          Audience: #{deck.audience}
+          Goal: #{deck.goal}
+
+          Return exactly 5 slides as a JSON array. Each item must be an object with
+          a "title" string and a "bullets" array of 2-4 short strings.
+          Respond with the JSON array only: no commentary, no markdown code fences,
+          and no reasoning or thinking content before or after it.
+        PROMPT
+      end
+
+      def chat_completion(prompt)
+        response = JSON.parse(post_chat_completion(prompt))
+        content = response.dig("choices", 0, "message", "content")
+        raise Error, "empty response from model" if content.to_s.strip.empty?
+
+        content
+      rescue JSON::ParserError => e
+        raise Error, "could not parse model response: #{e.message}"
+      end
+
+      def post_chat_completion(prompt)
+        uri = endpoint_uri("chat/completions")
+        request = build_request(uri, prompt)
+        response = perform_request(uri, request)
+
+        raise Error, "#{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+        response.body
+      end
+
+      def perform_request(uri, request)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == "https",
+                        open_timeout: 5,
+                        read_timeout: 30,
+                        write_timeout: 30) do |http|
+          http.request(request)
+        end
+      rescue StandardError => e
+        raise Error, e.message
+      end
+
+      def endpoint_uri(path)
+        base = @base_url.to_s.sub(%r{/+\z}, "")
+        URI.join("#{base}/", path)
+      end
+
+      def build_request(uri, prompt)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@api_key}"
+        request.body = JSON.generate(
+          model: @model,
+          messages: [{ role: "user", content: prompt }],
+          temperature: 0.7
+        )
+        request
+      end
+
+      def slides_from(content)
+        parsed = JSON.parse(extract_json_array(content))
+        raise Error, "expected a JSON array of slides" unless parsed.is_a?(Array)
+
+        parsed.map do |item|
+          Slide.new(title: item.fetch("title"), bullets: Array(item.fetch("bullets")))
+        end
+      rescue JSON::ParserError, KeyError => e
+        raise Error, "could not parse model response: #{e.message}"
+      end
+
+      # Some models (especially reasoning models served through LM Studio or
+      # Ollama) prepend or append thinking/reasoning text around the JSON
+      # answer instead of returning it verbatim, so the array is extracted from
+      # within the raw content rather than parsed as-is.
+      def extract_json_array(content)
+        content.enum_for(:scan, /\[/).each do
+          start = Regexp.last_match.begin(0)
+          candidate = json_array_from(content, start)
+          return candidate if candidate
+        end
+
+        raise Error, "no JSON array found in model response"
+      end
+
+      def json_array_from(content, start)
+        finish = start
+        while (finish = content.index("]", finish))
+          candidate = content[start..finish]
+          return candidate if parses_to_array?(candidate)
+
+          finish += 1
+        end
+        nil
+      end
+
+      def parses_to_array?(candidate)
+        JSON.parse(candidate).is_a?(Array)
+      rescue JSON::ParserError
+        false
+      end
+    end
+  end
+end