slidict 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be7eb12f72a7017dada85767aef5a2723e0c7ebd28a7d3b8dd5725098903e0c2
+  data.tar.gz: c7be11bc74153be8ea5fd0ae52e62bcb62fdfed5ec6a57fce05642cc5b341432
+SHA512:
+  metadata.gz: f597120d84f08d011fdae68253d950efae06633fb8e5a15166f86a2e4f995c7b75e0004925b0fa9c385e7514e5b0d421d4eb68edb487e637d7016b9c713d8e3d
+  data.tar.gz: 26792e2c9d343f849790d4fc83b1bf2cefa7f4a638487eac3ea25c71795713fb960d8cceac0bf8d51390f8d409506906089639e76c70c55bebe58d645651bc37

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "bundler" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

data/.github/release-drafter.yml

@@ -0,0 +1,23 @@
+name-template: 'v$NEXT_PATCH_VERSION'
+tag-template: 'v$NEXT_PATCH_VERSION'
+template: |
+  ## Changes
+
+  $CHANGES
+
+  ## Contributors
+
+  $CONTRIBUTORS
+
+categories:
+  - title: '🚀 Features'
+    labels:
+      - 'feat'
+  - title: '🐛 Fixes'
+    labels:
+      - 'fix'
+  - title: '🧰 Maintenance'
+    labels:
+      - 'chore'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+no-changes-template: '- No changes'

data/.github/workflows/changelog.yml

@@ -0,0 +1,50 @@
+name: Changelog
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  changelog:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+
+      - name: Extract version
+        id: version
+        run: |
+          version=$(grep -Eo "[0-9]+\.[0-9]+\.[0-9]+" lib/prspec/ruby/version.rb | head -n 1)
+          echo "version=v$version" >> $GITHUB_ENV
+          echo "VERSION_TAG=v$version" >> $GITHUB_ENV
+
+      - name: Check if version tag exists
+        id: check_tag
+        run: |
+          if gh release view "$VERSION_TAG" --json tagName > /dev/null 2>&1; then
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate CHANGELOG with requarks/changelog-action
+        if: steps.check_tag.outputs.exists == 'true'
+        id: changelog
+        uses: requarks/changelog-action@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ env.VERSION_TAG }}
+          writeToFile: true
+          changelogFilePath: CHANGELOG.md
+
+      - name: Draft release with release-drafter
+        if: steps.check_tag.outputs.exists == 'false'
+        uses: release-drafter/release-drafter@v5
+        with:
+          config-name: release-drafter.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/.github/workflows/gem-push.yml

@@ -0,0 +1,92 @@
+name: Ruby Gem
+
+on:
+  push:
+    tags: [ 'v*' ]
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Set up Ruby 3.4
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.4.3
+
+    - name: Extract version
+      id: version
+      run: |
+        version=$(echo "${GITHUB_REF#refs/tags/}")
+        echo "version=$version" >> $GITHUB_ENV
+
+    - name: Check if a previous tag exists
+      id: previous_tag
+      run: |
+        if [ "$(git tag --list 'v*' | wc -l)" -gt 1 ]; then
+          echo "exists=true" >> $GITHUB_OUTPUT
+        else
+          echo "exists=false" >> $GITHUB_OUTPUT
+        fi
+
+    - name: Generate CHANGELOG
+      if: steps.previous_tag.outputs.exists == 'true'
+      id: changelog
+      uses: requarks/changelog-action@v1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+        tag: ${{ env.version }}
+        writeToFile: true
+        changelogFilePath: CHANGELOG.md
+        includeRefIssues: true
+        useGitmojis: true
+
+    - name: Commit updated CHANGELOG.md
+      if: steps.previous_tag.outputs.exists == 'true'
+      run: |
+        git config user.name "github-actions"
+        git config user.email "github-actions@github.com"
+        git add CHANGELOG.md
+        git commit -m "docs: update CHANGELOG for ${{ env.version }}" || echo "No changes to commit"
+        git push origin HEAD:main
+      continue-on-error: true
+
+    - name: Update GitHub Release
+      uses: ncipollo/release-action@v1
+      with:
+        allowUpdates: true
+        tag: ${{ env.version }}
+        name: ${{ env.version }}
+        body: ${{ steps.changelog.outputs.changes }}
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Publish to GPR
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:github: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
+      env:
+        GEM_HOST_API_KEY: "Bearer ${{ secrets.GITHUB_TOKEN }}"
+        OWNER: ${{ github.repository_owner }}
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem build *.gemspec
+        gem push *.gem
+      env:
+        GEM_HOST_API_KEY: "${{ secrets.RUBYGEMS_AUTH_TOKEN }}"

data/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: Test
+
+on:
+  pull_request:
+
+jobs:
+  ruby:
+    name: Ruby tests
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby-version: ["3.2", "3.3", "3.4", "4.0"]
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          persist-credentials: false
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Run test suite
+        run: bundle exec rake spec
+
+      - name: Smoke test CLI
+        run: |
+          printf 'PDF Difference Monitoring Service\n5 minutes\nEngineering managers\nApprove an MVP pilot\n' | bin/slidict --output /tmp/slidict-smoke.md
+          test -s /tmp/slidict-smoke.md
+          grep -q '# PDF Difference Monitoring Service' /tmp/slidict-smoke.md

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [v0.1.2] - 2026-06-21
+### :wrench: Chores
+- [`12bd765`](https://github.com/slidict/slidict/commit/12bd765c172267431349cf028b011db73f921721) - bump version 0.1.2 *(commit by [@abechan1](https://github.com/abechan1))*
+- [`c46fff3`](https://github.com/slidict/slidict/commit/c46fff3fef785e661b2e9cd41fc2f01ae725c984) - stop tracking Gemfile.lock *(commit by [@abechan1](https://github.com/abechan1))*
+
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-21
+
+- Initial release
+[v0.1.2]: https://github.com/slidict/slidict/compare/v0.1.1...v0.1.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"slidict" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["255824173+abechan1@users.noreply.github.com"](mailto:"255824173+abechan1@users.noreply.github.com").

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 slidict
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yusuke Abe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# Slidict
+
+Generate presentation-ready slides from a simple conversation.
+
+Slidict is a CLI tool that helps you turn rough ideas into presentations through AI-guided conversations.
+
+Unlike traditional slide generators, Slidict focuses on communication before slide creation.
+
+## Features
+
+- Interactive CLI conversation
+- Generate Markdown slides for Slidev, Marp, Asciidoctor Reveal.js, and other OSS presentation frameworks
+- Local-first MVP implemented in Ruby
+- OpenAI Compatible API support, so you can point Slidict at OpenAI, Ollama, LM Studio, vLLM, or any other server implementing the same `/chat/completions` endpoint
+
+## Requirements
+
+- Ruby 3.1 or later
+
+## Usage
+
+Run the executable directly from this repository:
+
+```bash
+bin/slidict
+```
+
+Slidict asks a few questions and writes `slides.md`:
+
+```bash
+$ bin/slidict
+
+What would you like to talk about?
+> PDF Difference Monitoring Service
+How long is the presentation?
+> 5 minutes
+Who is the audience?
+> Engineering managers
+What should the audience remember or do?
+> Approve an MVP pilot
+Created slides.md
+```
+
+You can also provide answers non-interactively:
+
+```bash
+bin/slidict \
+  --topic "PDF Difference Monitoring Service" \
+  --duration "5 minutes" \
+  --audience "Engineering managers" \
+  --goal "Approve an MVP pilot" \
+  --framework slidev \
+  --output slides.md
+```
+
+Output:
+
+```text
+slides.md
+```
+
+## Configuration
+
+Slidict generates slides with an LLM through any OpenAI Compatible API. Configure the
+target endpoint with environment variables or CLI flags (flags take precedence):
+
+| Environment variable    | CLI flag         | Default        |
+| ------------------------ | ---------------- | -------------- |
+| `SLIDICT_LLM_BASE_URL`    | `--llm-base-url` | _(none)_       |
+| `SLIDICT_LLM_API_KEY`     | `--llm-api-key`  | _(none)_       |
+| `SLIDICT_LLM_MODEL`       | `--llm-model`    | `gpt-4o-mini`  |
+
+If no `llm-base-url` is configured, Slidict uses its built-in slide template and never
+calls an LLM. Once a `llm-base-url` is set, Slidict always calls that endpoint; if the
+request fails, Slidict reports the error and exits without writing a file (no fallback).
+You can force the template even when a base URL is configured with `--no-llm`.
+
+Examples:
+
+```bash
+# OpenAI
+export SLIDICT_LLM_BASE_URL=https://api.openai.com/v1
+export SLIDICT_LLM_API_KEY=sk-...
+bin/slidict --topic "PDF Difference Monitoring Service" --duration "5 minutes" \
+  --audience "Engineering managers" --goal "Approve an MVP pilot"
+
+# Ollama (running locally, OpenAI Compatible API)
+bin/slidict --llm-base-url http://localhost:11434/v1 --llm-api-key ollama --llm-model llama3
+
+# LM Studio (running locally, OpenAI Compatible API)
+bin/slidict --llm-base-url http://localhost:1234/v1 --llm-api-key lm-studio --llm-model local-model
+```
+
+## Philosophy
+
+Slidict helps you communicate ideas, not just create slides.
+
+Many presentation tools focus on layouts, themes, and visual design.
+
+Slidict focuses on the message.
+
+Before generating slides, Slidict helps you:
+
+- Clarify your message
+- Build a compelling narrative
+- Focus on what matters
+- Create presentations people remember
+
+```text
+Idea
+ ↓
+Conversation
+ ↓
+Story
+ ↓
+Slides
+```
+
+We optimize for communication, not decoration.
+
+## Roadmap
+
+- [x] Interactive CLI
+- [x] Slide generation
+- [x] OpenAI Compatible API support (configurable base URL, so Ollama, LM Studio, and other compatible servers work out of the box)
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/slidict/cli.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Slidict
+  class CLI
+    DEFAULT_OUTPUT = "slides.md"
+
+    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 = { output: DEFAULT_OUTPUT, 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
+    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-ready Markdown slides 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: slides.md)
+        -h, --help             Show this help
+      HELP
+      0
+    end
+  end
+end

data/lib/slidict/config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Slidict
+  class Config
+    DEFAULT_MODEL = "gpt-4o-mini"
+
+    attr_reader :base_url, :api_key, :model
+
+    def initialize(base_url: nil, api_key: nil, model: DEFAULT_MODEL, enabled: true)
+      @base_url = base_url
+      @api_key = api_key
+      @model = model
+      @enabled = enabled
+    end
+
+    def self.from_env(env = ENV)
+      new(
+        base_url: env["SLIDICT_LLM_BASE_URL"],
+        api_key: env["SLIDICT_LLM_API_KEY"],
+        model: env["SLIDICT_LLM_MODEL"] || DEFAULT_MODEL
+      )
+    end
+
+    def merge(base_url: nil, api_key: nil, model: nil, enabled: nil)
+      self.class.new(
+        base_url: base_url || @base_url,
+        api_key: api_key || @api_key,
+        model: model || @model,
+        enabled: enabled.nil? ? @enabled : enabled
+      )
+    end
+
+    # An llm-base-url is required to enable the LLM call; otherwise the
+    # built-in slide template is used.
+    def llm_enabled?
+      @enabled && !base_url.to_s.strip.empty?
+    end
+  end
+end

data/lib/slidict/deck.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Slidict
+  Slide = Struct.new(:title, :bullets, keyword_init: true)
+
+  class Deck
+    attr_reader :topic, :duration, :audience, :goal, :framework
+
+    def initialize(topic:, duration:, audience:, goal:, framework: "slidev", slides: nil)
+      @topic = normalize(topic, fallback: "Untitled presentation")
+      @duration = normalize(duration, fallback: "5 minutes")
+      @audience = normalize(audience, fallback: "general audience")
+      @goal = normalize(goal, fallback: "understand the key message")
+      @framework = normalize(framework, fallback: "slidev").downcase
+      @slides = slides
+    end
+
+    def slides
+      @slides || default_slides
+    end
+
+    private
+
+    def default_slides
+      [
+        Slide.new(title: topic, bullets: ["For #{audience}", "Goal: #{goal}", "Length: #{duration}"]),
+        Slide.new(title: "Why this matters", bullets: ["Clarifies the problem before discussing solutions", "Keeps the story focused on audience value", "Sets up a memorable takeaway"]),
+        Slide.new(title: "Core message", bullets: ["#{topic} should be easy to explain", "Every slide should support: #{goal}", "Details are included only when they help the audience decide or act"]),
+        Slide.new(title: "Suggested narrative", bullets: ["Start with the current pain or opportunity", "Show what changes when #{topic} works well", "Close with the next step you want the audience to take"]),
+        Slide.new(title: "Next steps", bullets: ["Review the generated outline", "Replace generic bullets with concrete examples", "Rehearse and refine for #{duration}"])
+      ]
+    end
+
+    def normalize(value, fallback:)
+      text = value.to_s.strip
+      text.empty? ? fallback : text
+    end
+  end
+end

data/lib/slidict/llm_client.rb

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Slidict
+  class MarkdownRenderer
+    FRONTMATTER_BY_FRAMEWORK = {
+      "slidev" => "theme: default\nclass: text-center",
+      "marp" => "marp: true\ntheme: default",
+      "asciidoctor-revealjs" => "revealjs_theme: white"
+    }.freeze
+
+    def render(deck)
+      [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
+  end
+end

data/lib/slidict/version.rb

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

data/lib/slidict.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "time"
+
+require_relative "slidict/cli"
+require_relative "slidict/config"
+require_relative "slidict/deck"
+require_relative "slidict/llm_client"
+require_relative "slidict/markdown_renderer"
+require_relative "slidict/version"
+
+module Slidict
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: slidict
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Yusuke Abe
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Slidict is a Ruby CLI for turning rough ideas into presentation-ready
+  Markdown slides.
+email:
+- 255824173+abechan1@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/dependabot.yml"
+- ".github/release-drafter.yml"
+- ".github/workflows/changelog.yml"
+- ".github/workflows/gem-push.yml"
+- ".github/workflows/test.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/slidict.rb
+- lib/slidict/cli.rb
+- lib/slidict/config.rb
+- lib/slidict/deck.rb
+- lib/slidict/llm_client.rb
+- lib/slidict/markdown_renderer.rb
+- lib/slidict/version.rb
+homepage: https://labs.slidict.io/slidict/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://labs.slidict.io/slidict/
+  source_code_uri: https://github.com/slidict/slidict
+  changelog_uri: https://github.com/slidict/slidict/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Generate presentation-ready slides from a simple conversation.
+test_files: []