slidict 0.2.0 → 0.4.0

metadata

@@ -1,14 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: slidict
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 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,22 @@ files:
 - README.md
 - Rakefile
 - lib/slidict.rb
-- lib/slidict/auth_client.rb
-- lib/slidict/cli.rb
+- lib/slidict/cli/app.rb
+- lib/slidict/cli/lint.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/lint/finding.rb
+- lib/slidict/lint/linter.rb
+- lib/slidict/lint/renderer.rb
+- lib/slidict/lint/slide_parser.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

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