slidict 0.2.0 → 0.3.1

data/lib/slidict/output/format.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Slidict
+  module Output
+    # Single source of truth for everything that varies per output framework:
+    # the output file extension, the body_format sent to the slidict.io API,
+    # and (for markdown-based frameworks) the frontmatter block to render.
+    # Add a new framework by adding one entry to REGISTRY.
+    class Format
+      Definition = Struct.new(:name, :extension, :body_format, :frontmatter, keyword_init: true)
+
+      DEFAULT_NAME = "slidev"
+
+      REGISTRY = {
+        "slidev" => Definition.new(
+          name: "slidev",
+          extension: ".md",
+          body_format: "markdown",
+          frontmatter: "theme: default\nclass: text-center"
+        ),
+        "marp" => Definition.new(
+          name: "marp",
+          extension: ".md",
+          body_format: "markdown",
+          frontmatter: "marp: true\ntheme: default"
+        ),
+        "asciidoctor-revealjs" => Definition.new(
+          name: "asciidoctor-revealjs",
+          extension: ".adoc",
+          body_format: "asciidoc",
+          frontmatter: nil
+        )
+      }.freeze
+
+      def self.fetch(name)
+        REGISTRY.fetch(name.to_s.downcase, REGISTRY.fetch(DEFAULT_NAME))
+      end
+
+      def self.names
+        REGISTRY.keys
+      end
+    end
+  end
+end

data/lib/slidict/output/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Slidict
+  module Output
+    class Renderer
+      def render(deck)
+        return render_asciidoctor_revealjs(deck) if Format.fetch(deck.framework).body_format == "asciidoc"
+
+        [frontmatter(deck.framework), deck.slides.map { |slide| render_slide(slide) }.join("\n---\n\n")].join("\n")
+      end
+
+      private
+
+      def frontmatter(framework)
+        body = Format.fetch(framework).frontmatter
+        "---\n#{body}\ngenerated: #{Time.now.utc.iso8601}\n---\n"
+      end
+
+      def render_slide(slide)
+        lines = ["# #{slide.title}", ""]
+        lines.concat(slide.bullets.map { |bullet| "- #{bullet}" })
+        lines.join("\n")
+      end
+
+      def render_asciidoctor_revealjs(deck)
+        lines = ["= #{deck.topic}", ":revealjs_theme: white", ":slidict_generated: #{Time.now.utc.iso8601}", ""]
+        lines.concat(deck.slides.flat_map { |slide| render_asciidoctor_slide(slide) })
+        lines.join("\n")
+      end
+
+      def render_asciidoctor_slide(slide)
+        ["== #{slide.title}", "", *slide.bullets.map { |bullet| "* #{bullet}" }, ""]
+      end
+    end
+  end
+end

data/lib/slidict/version.rb

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

data/lib/slidict.rb

@@ -2,15 +2,17 @@
 
 require "time"
 
-require_relative "slidict/auth_client"
-require_relative "slidict/cli"
+require_relative "slidict/cli/app"
+require_relative "slidict/cli/serve"
+require_relative "slidict/cli/slides"
 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/external/slidict_io/auth"
+require_relative "slidict/external/slidict_io/client"
+require_relative "slidict/external/slidict_io/credentials"
+require_relative "slidict/llm/client"
+require_relative "slidict/output/format"
+require_relative "slidict/output/renderer"
 require_relative "slidict/version"
 
 module Slidict

metadata

@@ -1,14 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: slidict
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Yusuke Abe
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: Slidict is a Ruby CLI for turning rough ideas into presentation-ready
   Markdown slides.
 email:
@@ -31,15 +73,17 @@ files:
 - README.md
 - Rakefile
 - lib/slidict.rb
-- lib/slidict/auth_client.rb
-- lib/slidict/cli.rb
+- lib/slidict/cli/app.rb
+- lib/slidict/cli/serve.rb
+- lib/slidict/cli/slides.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/external/slidict_io/auth.rb
+- lib/slidict/external/slidict_io/client.rb
+- lib/slidict/external/slidict_io/credentials.rb
+- lib/slidict/llm/client.rb
+- lib/slidict/output/format.rb
+- lib/slidict/output/renderer.rb
 - lib/slidict/version.rb
 homepage: https://labs.slidict.io/slidict/
 licenses:

data/lib/slidict/auth_client.rb

@@ -1,75 +0,0 @@
-# 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

@@ -1,266 +0,0 @@
-# frozen_string_literal: true
-
-module Slidict
-  class CLI
-    DEFAULT_OUTPUT = "slides.md"
-    DEFAULT_OUTPUT_BY_FRAMEWORK = {
-      "slidev" => "slides.md",
-      "marp" => "slides.md",
-      "asciidoctor-revealjs" => "slides.adoc"
-    }.freeze
-
-    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)
-      return 1 if client && !verify_connection(client)
-
-      deck = Deck.new(
-        topic: ask("What would you like to talk about?", options[:topic]),
-        duration: ask("How long is the presentation?", options[:duration]),
-        audience: ask("Who is the audience?", options[:audience]),
-        goal: ask("What should the audience remember or do?", options[:goal]),
-        framework: options[:framework]
-      )
-
-      if client
-        begin
-          slides = client.generate_slides(deck)
-        rescue LLMClient::Error => e
-          @output.puts "Error: LLM request failed (#{e.message})"
-          return 1
-        end
-        deck = Deck.new(
-          topic: deck.topic, duration: deck.duration, audience: deck.audience, goal: deck.goal,
-          framework: deck.framework, slides: slides
-        )
-      end
-
-      path = options[:output]
-      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 => e
-      @output.puts "Error: #{e.message}"
-      @output.puts
-      print_help
-      1
-    end
-
-    private
-
-    def parse(argv)
-      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"
-          options[:help] = true
-        when "-o", "--output"
-          options[:output] = fetch_value!(args, arg)
-        when "--topic"
-          options[:topic] = fetch_value!(args, arg)
-        when "--duration"
-          options[:duration] = fetch_value!(args, arg)
-        when "--audience"
-          options[:audience] = fetch_value!(args, arg)
-        when "--goal"
-          options[:goal] = fetch_value!(args, arg)
-        when "--framework"
-          options[:framework] = fetch_value!(args, arg)
-        when "--llm-base-url"
-          options[:llm_base_url] = fetch_value!(args, arg)
-        when "--llm-api-key"
-          options[:llm_api_key] = fetch_value!(args, arg)
-        when "--llm-model"
-          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
-      end
-
-      options[:output] ||= default_output_for(options[:framework])
-      options
-    end
-
-    def build_config(options)
-      Config.from_env.merge(
-        base_url: options[:llm_base_url],
-        api_key: options[:llm_api_key],
-        model: options[:llm_model],
-        enabled: options[:no_llm] ? false : nil
-      )
-    end
-
-    def llm_client_for(config)
-      return nil unless config.llm_enabled?
-
-      LLMClient.new(base_url: config.base_url, api_key: config.api_key, model: config.model)
-    end
-
-    def verify_connection(client)
-      client.verify_connection!
-      true
-    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?("-")
-
-      value
-    end
-
-    def ask(question, provided)
-      return provided unless provided.nil? || provided.strip.empty?
-
-      @output.puts question
-      @output.print "> "
-      @input.gets&.chomp.to_s
-    end
-
-    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"
-            --audience TEXT    Target audience
-            --goal TEXT        Desired audience takeaway or action
-            --framework NAME   slidev, marp, or asciidoctor-revealjs (default: slidev)
-            --llm-base-url URL OpenAI Compatible API base URL (env: SLIDICT_LLM_BASE_URL).
-                               When omitted, the built-in slide template is used instead.
-            --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
-      0
-    end
-
-    def default_output_for(framework)
-      DEFAULT_OUTPUT_BY_FRAMEWORK.fetch(framework.to_s.downcase, DEFAULT_OUTPUT)
-    end
-  end
-end

data/lib/slidict/credentials.rb

@@ -1,39 +0,0 @@
-# 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