slidict 0.1.9 → 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.1.9"
+  VERSION = "0.3.1"
 end

data/lib/slidict.rb

@@ -2,11 +2,17 @@
 
 require "time"
 
-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/deck"
-require_relative "slidict/llm_client"
-require_relative "slidict/markdown_renderer"
+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.1.9
+  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:
@@ -23,6 +65,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 +73,17 @@ files:
 - README.md
 - Rakefile
 - lib/slidict.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/deck.rb
-- lib/slidict/llm_client.rb
-- lib/slidict/markdown_renderer.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/cli.rb

@@ -1,162 +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)
-      @input = input
-      @output = output
-      @renderer = renderer
-    end
-
-    def run(argv = [])
-      options = parse(argv)
-      return print_help if options[:help]
-
-      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 => error
-          @output.puts "Error: LLM request failed (#{error.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]
-      File.write(path, @renderer.render(deck))
-      @output.puts "Created #{path}"
-      0
-    rescue ArgumentError => error
-      @output.puts "Error: #{error.message}"
-      @output.puts
-      print_help
-      1
-    end
-
-    private
-
-    def parse(argv)
-      options = { framework: "slidev" }
-      args = argv.dup
-
-      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
-        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 => error
-      @output.puts "Error: LLM request failed (#{error.message})"
-      false
-    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]
-
-        Generate presentation source files from a short conversation.
-
-        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
-        -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/llm_client.rb

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

data/lib/slidict/markdown_renderer.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Slidict
-  class MarkdownRenderer
-    FRONTMATTER_BY_FRAMEWORK = {
-      "slidev" => "theme: default\nclass: text-center",
-      "marp" => "marp: true\ntheme: default"
-    }.freeze
-
-    def render(deck)
-      return render_asciidoctor_revealjs(deck) if deck.framework == "asciidoctor-revealjs"
-
-      [frontmatter(deck.framework), deck.slides.map { |slide| render_slide(slide) }.join("\n---\n\n")].join("\n")
-    end
-
-    private
-
-    def frontmatter(framework)
-      body = FRONTMATTER_BY_FRAMEWORK.fetch(framework, FRONTMATTER_BY_FRAMEWORK["slidev"])
-      "---\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