slidict 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbc5e790dd61153be274e56924cf62275c6f7faecc62fadeb1be61112d2b7c22
-  data.tar.gz: 0a1af3694e1bce28b2f21a4d0898fad0034ff6fe3460b9d53e18236668a5b4f4
+  metadata.gz: cc62a4a9def18173cd4fa3c36a07b8113cbd952f3ecef69f25d31bdd8a0c2c29
+  data.tar.gz: b559163e5add314725911941fece8829b47cd79f801369a4735a5b62fb6aadfb
 SHA512:
-  metadata.gz: 7f037d810c7174a44b83f83666d186377edc3171d76bbc130f555f856252976065e752e9a44212369bbe08a2354480305ece22b1962851962366137416ef3f60
-  data.tar.gz: 141a0c3e8b00c02f35519b293be29b5033ed61ea75959f25a788c6da977d31907c78470a7fba99f7cc8adcf508880e86f90f4e20cde36da21db6d249690e6eff
+  metadata.gz: 7482973532b58361216b54dc6a45e81bee4bc39e65e9a26958c37c271cdcb97f5c915649ee26d88973f4e34f26a9a7eb2b56a0ad7224488bd87a739087201d25
+  data.tar.gz: 946075256cf69b70511aae347f2d6a15164f87aeb4bd0678ac329af8a367773c515aec5a09bc4cab52a42b475e4aff7ec26995cbb7fce8f191ee3c12accea668

data/AGENTS.md

@@ -0,0 +1,41 @@
+# AGENTS.md
+
+Guidance for AI coding agents working in this repository.
+
+## Project overview
+
+Slidict is a Ruby CLI gem that turns conversational input into presentation
+source files (Slidev, Marp, Asciidoctor Reveal.js, etc.) via an
+OpenAI-compatible chat API.
+
+## Setup
+
+- Ruby 3.1+
+- Install dependencies: `bundle install`
+
+## Development workflow
+
+- Run tests: `bundle exec rspec`
+- Run lint: `bundle exec rubocop`
+- Run the CLI locally: `bin/slidict`
+
+Run both tests and lint before considering a change complete.
+
+When you add or change a CLI command (or its options), update the "Commands" section
+of `README.md` to document it.
+
+## Commit conventions
+
+Use Conventional Commits for every commit message: `<type>: <summary>`.
+
+Common types used in this repo:
+
+- `feat:` new functionality
+- `fix:` bug fixes
+- `chore:` maintenance, version bumps, dependency updates
+- `ci:` CI/workflow changes
+- `docs:` documentation only changes
+- `refactor:` code change that neither fixes a bug nor adds a feature
+- `test:` adding or correcting tests
+
+Keep the summary short and in the imperative mood (e.g. `fix: handle empty topic input`).

data/README.md

@@ -53,6 +53,20 @@ bin/slidict \
   --output slides.adoc
 ```
 
+Add `--publish` to also save the generated slides to slidict.io as a draft (requires
+`slidict auth` first). Pass `--slide-id` to edit an existing draft instead of creating a
+new one:
+
+```bash
+# Create a new draft on slidict.io from the generated slides
+bin/slidict --topic "PDF Difference Monitoring Service" --duration "5 minutes" \
+  --audience "Engineering managers" --goal "Approve an MVP pilot" --publish
+
+# Edit an existing draft (slide #42) instead of creating a new one
+bin/slidict --topic "PDF Difference Monitoring Service" --duration "5 minutes" \
+  --audience "Engineering managers" --goal "Approve an MVP pilot" --slide-id 42
+```
+
 ## Output files
 
 Choose the framework and output path that match the presentation tool you want to use. If you omit `--output`, Slidict chooses a framework-specific default:
@@ -63,6 +77,39 @@ Marp                    -> slides.md
 Asciidoctor Reveal.js   -> slides.adoc
 ```
 
+## Commands
+
+### `slidict auth`
+
+Authenticates the CLI with your GitHub account via the device code flow and saves a
+CLI access token to `~/.config/slidict/credentials.json`.
+
+```bash
+bin/slidict auth
+```
+
+### `slidict slides`
+
+Manage your slides on slidict.io using the CLI access token saved by `slidict auth`.
+
+```bash
+bin/slidict slides list [--page N]
+bin/slidict slides show <id>
+bin/slidict slides create [--title TEXT] [--body TEXT | --file PATH] [--body-format asciidoc|markdown] [--visibility public|unlisted|group_only]
+bin/slidict slides edit <id> [--title TEXT] [--body TEXT | --file PATH] [--body-format asciidoc|markdown] [--visibility public|unlisted|group_only]
+```
+
+- `create` and `edit` always save the slide as a draft. Publishing requires going through
+  the moderation flow on the Web UI; the CLI cannot publish a slide.
+- `edit` only works on slides that are still drafts; editing an already-published slide
+  must be done from the Web UI.
+- `create`/`edit` are rate limited to once per minute per user.
+
+Run `bin/slidict slides -h` for the full list of options.
+
+`bin/slidict --publish` and `--slide-id` (see [Usage](#usage)) wrap this same `create`/`edit`
+behavior so you can save the slides you just generated straight to slidict.io.
+
 ## Configuration
 
 Slidict generates slides with an LLM through any OpenAI Compatible API. Configure the

data/lib/slidict/auth_client.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Slidict
+  class AuthClient
+    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") 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

data/lib/slidict/cli.rb

@@ -9,15 +9,22 @@ module Slidict
       "asciidoctor-revealjs" => "slides.adoc"
     }.freeze
 
-    def initialize(input: $stdin, output: $stdout, renderer: MarkdownRenderer.new)
+    def initialize(input: $stdin, output: $stdout, renderer: MarkdownRenderer.new, auth_client: nil,
+                   credentials: nil, sleeper: Kernel, slides_command: nil)
       @input = input
       @output = output
       @renderer = renderer
+      @auth_client = auth_client
+      @credentials = credentials
+      @sleeper = sleeper
+      @slides_command = slides_command
     end
 
     def run(argv = [])
       options = parse(argv)
       return print_help if options[:help]
+      return auth if options[:command] == "auth"
+      return slides(options[:args]) if options[:command] == "slides"
 
       config = build_config(options)
       client = llm_client_for(config)
@@ -34,8 +41,8 @@ module Slidict
       if client
         begin
           slides = client.generate_slides(deck)
-        rescue LLMClient::Error => error
-          @output.puts "Error: LLM request failed (#{error.message})"
+        rescue LLMClient::Error => e
+          @output.puts "Error: LLM request failed (#{e.message})"
           return 1
         end
         deck = Deck.new(
@@ -45,11 +52,15 @@ module Slidict
       end
 
       path = options[:output]
-      File.write(path, @renderer.render(deck))
+      content = @renderer.render(deck)
+      File.write(path, content)
       @output.puts "Created #{path}"
+
+      return publish_to_slidict(deck, content, options) if options[:publish] || options[:slide_id]
+
       0
-    rescue ArgumentError => error
-      @output.puts "Error: #{error.message}"
+    rescue ArgumentError => e
+      @output.puts "Error: #{e.message}"
       @output.puts
       print_help
       1
@@ -61,6 +72,21 @@ module Slidict
       options = { framework: "slidev" }
       args = argv.dup
 
+      if args.first == "auth"
+        args.shift
+        raise ArgumentError, "auth does not accept options" unless args.empty?
+
+        options[:command] = "auth"
+        return options
+      end
+
+      if args.first == "slides"
+        args.shift
+        options[:command] = "slides"
+        options[:args] = args
+        return options
+      end
+
       until args.empty?
         case (arg = args.shift)
         when "-h", "--help"
@@ -85,6 +111,14 @@ module Slidict
           options[:llm_model] = fetch_value!(args, arg)
         when "--no-llm"
           options[:no_llm] = true
+        when "--publish"
+          options[:publish] = true
+        when "--slide-id"
+          options[:slide_id] = fetch_value!(args, arg)
+        when "--slide-title"
+          options[:slide_title] = fetch_value!(args, arg)
+        when "--visibility"
+          options[:visibility] = fetch_value!(args, arg)
         else
           raise ArgumentError, "unknown option #{arg}"
         end
@@ -112,11 +146,68 @@ module Slidict
     def verify_connection(client)
       client.verify_connection!
       true
-    rescue LLMClient::Error => error
-      @output.puts "Error: LLM request failed (#{error.message})"
+    rescue LLMClient::Error => e
+      @output.puts "Error: LLM request failed (#{e.message})"
       false
     end
 
+    def auth
+      client = @auth_client || AuthClient.new
+      credentials = @credentials || Credentials.new
+
+      device = client.request_device_code
+      @output.puts "1. Open #{device[:verification_uri]} in your browser"
+      @output.puts "2. Enter code: #{device[:user_code]}"
+      @output.puts "3. Log in with GitHub"
+      @output.puts "Waiting for GitHub authentication..."
+
+      deadline = Time.now + device[:expires_in]
+      loop do
+        token = client.poll_token(device_code: device[:device_code])
+        path = credentials.write_cli_token!(
+          access_token: token.fetch("access_token"),
+          token_type: token.fetch("token_type", "Bearer"),
+          provider: token.fetch("provider", "github")
+        )
+        @output.puts "4. Saved CLI access token to #{path}"
+        return 0
+      rescue AuthClient::Pending
+        return login_expired if Time.now >= deadline
+
+        @sleeper.sleep(device[:interval])
+      end
+    rescue AuthClient::Error, KeyError => e
+      @output.puts "Error: GitHub auth failed (#{e.message})"
+      1
+    end
+
+    def slides(args)
+      slides_command.run(args)
+    end
+
+    def publish_to_slidict(deck, content, options)
+      slides_command.publish(
+        id: options[:slide_id],
+        title: options[:slide_title] || deck.topic,
+        body: content,
+        body_format: body_format_for(deck.framework),
+        visibility: options[:visibility]
+      )
+    end
+
+    def slides_command
+      @slides_command ||= SlidesCommand.new(output: @output, credentials: @credentials, reauthenticate: method(:auth))
+    end
+
+    def body_format_for(framework)
+      framework.to_s.downcase == "asciidoctor-revealjs" ? "asciidoc" : "markdown"
+    end
+
+    def login_expired
+      @output.puts "Error: GitHub auth timed out. Run `slidict auth` and try again."
+      1
+    end
+
     def fetch_value!(args, option)
       value = args.shift
       raise ArgumentError, "#{option} requires a value" if value.nil? || value.start_with?("-")
@@ -135,9 +226,15 @@ module Slidict
     def print_help
       @output.puts <<~HELP
         Usage: slidict [options]
+        Usage: slidict auth
+        Usage: slidict slides <list|show|create|edit> [options]
 
         Generate presentation source files from a short conversation.
 
+        Commands:
+          auth             Authenticate the CLI with GitHub and save a CLI access token
+          slides           Manage your slides on slidict.io (run `slidict slides -h` for details)
+
         Options:
             --topic TEXT       Presentation topic
             --duration TEXT    Presentation length, for example "5 minutes"
@@ -149,6 +246,13 @@ module Slidict
             --llm-api-key KEY  API key for the LLM endpoint (env: SLIDICT_LLM_API_KEY)
             --llm-model NAME   Model name to request (env: SLIDICT_LLM_MODEL, default: gpt-4o-mini)
             --no-llm           Skip the LLM call and use the built-in slide template
+            --publish          Publish the generated slides to slidict.io as a draft
+                               (requires `slidict auth`; creates a new slide, or edits
+                               an existing one when --slide-id is given)
+            --slide-id ID      Edit this existing draft instead of creating a new one
+                               (implies --publish)
+            --slide-title TEXT Title for the published slide (default: --topic)
+            --visibility VIS   public, unlisted, or group_only (default: public)
         -o, --output PATH      Output file (default depends on --framework)
         -h, --help             Show this help
       HELP

data/lib/slidict/credentials.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Slidict
+  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

data/lib/slidict/slides_client.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Slidict
+  # Talks to the slidict.io CLI slides API using a CLI access token
+  # (obtained via Slidict::AuthClient / `slidict auth`).
+  class SlidesClient
+    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") 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

data/lib/slidict/slides_command.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module Slidict
+  # Implements the `slidict slides <list|show|create|edit>` subcommands.
+  class SlidesCommand
+    def initialize(output:, credentials: nil, client: nil, reauthenticate: nil)
+      @output = output
+      @credentials = credentials || 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
+
+    def fetch_value!(args, option)
+      value = args.shift
+      raise ArgumentError, "#{option} requires a value" if value.nil? || value.start_with?("-")
+
+      value
+    end
+
+    def list(options)
+      print_slide_list(client.list(page: options[:page]))
+      0
+    rescue SlidesClient::Error => e
+      print_client_error(e)
+    end
+
+    def show(options)
+      print_slide_detail(client.show(options[:id]))
+      0
+    rescue SlidesClient::NotFound
+      @output.puts "Error: slide not found"
+      1
+    rescue SlidesClient::Error => e
+      print_client_error(e)
+    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)
+      reauthenticated = false
+      begin
+        slide = yield
+        @output.puts "#{verb} slide ##{slide["id"]} (draft)"
+        print_slide_detail(slide)
+        0
+      rescue SlidesClient::NotFound
+        @output.puts "Error: slide not found"
+        1
+      rescue SlidesClient::NotEditable
+        @output.puts "Error: this slide is already published. Edit it from the Web UI instead."
+        1
+      rescue SlidesClient::RateLimited
+        print_rate_limited
+      rescue SlidesClient::Unprocessable => e
+        print_unprocessable(e)
+      rescue SlidesClient::Unauthorized => e
+        if !reauthenticated && reauthenticate!
+          reauthenticated = true
+          retry
+        end
+        print_client_error(e)
+      rescue SlidesClient::Error => e
+        print_client_error(e)
+      end
+    end
+
+    def read_body(options)
+      return File.read(options[:file]) if options[:file]
+
+      options[:body]
+    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
+
+        SlidesClient.new(access_token: token[:access_token], token_type: token[:token_type])
+      end
+    end
+
+    # Triggers the injected login flow (see Slidict::CLI#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

data/lib/slidict/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slidict
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

data/lib/slidict.rb

@@ -2,11 +2,15 @@
 
 require "time"
 
+require_relative "slidict/auth_client"
 require_relative "slidict/cli"
 require_relative "slidict/config"
+require_relative "slidict/credentials"
 require_relative "slidict/deck"
 require_relative "slidict/llm_client"
 require_relative "slidict/markdown_renderer"
+require_relative "slidict/slides_client"
+require_relative "slidict/slides_command"
 require_relative "slidict/version"
 
 module Slidict

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slidict
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Yusuke Abe
@@ -23,6 +23,7 @@ files:
 - ".github/workflows/changelog.yml"
 - ".github/workflows/gem-push.yml"
 - ".github/workflows/test.yml"
+- AGENTS.md
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE
@@ -30,11 +31,15 @@ files:
 - README.md
 - Rakefile
 - lib/slidict.rb
+- lib/slidict/auth_client.rb
 - lib/slidict/cli.rb
 - lib/slidict/config.rb
+- lib/slidict/credentials.rb
 - lib/slidict/deck.rb
 - lib/slidict/llm_client.rb
 - lib/slidict/markdown_renderer.rb
+- lib/slidict/slides_client.rb
+- lib/slidict/slides_command.rb
 - lib/slidict/version.rb
 homepage: https://labs.slidict.io/slidict/
 licenses: