slidict 0.5.3 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc5350820094f49312526c30c254f437edd49374ac0202ba99067637a70dd331
-  data.tar.gz: 130980c85ff4a85a0189b95fddc825ea30eeae131e1549d83e80cee1ae5ba392
+  metadata.gz: 31c1ca403d68f971c84728e80c5aafda7af449fa5d7b9b7be6202c49472c615f
+  data.tar.gz: 363578c6cfd6c0da50346204b124d10fa5779e7a0f73b262b0a3f1bd2854266c
 SHA512:
-  metadata.gz: d27d844ad6ed53f6d860fe92e8614fad35e19caa10a9e5395b4eb6640c314a0224b0c32a5de612f13cababc8e438f61c1d6103d5a5c3a8133e2021eb67be6f73
-  data.tar.gz: 241380442ea402ed968bbd7829ec8ec49446f70d7f80852d75248a829d041b09d7a9c62d9ead1341d49e6dd5beff152340c7766f822bd064c29a1e0c407fb200
+  metadata.gz: d58f207c65c0b1e0ea8d0e9369aa40dce69af3e54bcedb56b0932a1b77d32238152e15194bcadfba824442c1bf47550e381ecefde58dc3525838ac42a4ae35d4
+  data.tar.gz: 41cb0a82175bdc62be2369dbe4ef65a3f0a9cf4716b6b0b044bbb8ca0a6aa2c767cf8b829a6f1a8704944b5fd1f5df610b1d3294a7478aa5dd5cd461290d459b

data/CHANGELOG.md

@@ -1,5 +1,7 @@
 ## [Unreleased]
 
+- Add source-text slide generation through `--text`, `--text-file`, and the reusable
+  `Slidict::Generator` integration API.
 - Add `slidict init` to create a `.env` file (for `SLIDICT_LLM_*`, `SLIDICT_FRAMEWORK`,
   and `SLIDICT_METHOD`) and add it to `.gitignore`. `.env` is loaded automatically and
   fills in unset environment variables; CLI flags still take precedence.

data/README.md

@@ -63,6 +63,34 @@ bin/slidict \
   --output slides.adoc
 ```
 
+To create a presentation from an existing article, memo, or other prose, pass the
+text directly or read it from a file. Source-text generation requires an LLM endpoint;
+the first non-empty line is used as the topic when `--topic` is omitted. Slidict asks
+the model to preserve the source's facts and examples instead of inventing claims.
+
+```bash
+bin/slidict --text-file proposal.md \
+  --llm-base-url https://api.openai.com/v1 \
+  --llm-api-key "$OPENAI_API_KEY" --llm-model gpt-4o-mini
+
+bin/slidict --text "Why our team should adopt automated accessibility testing ..." \
+  --llm-base-url http://localhost:11434/v1 --llm-api-key ollama --llm-model llama3
+```
+
+Applications can use the same pipeline without CLI or filesystem side effects. The
+result contains both the structured `deck` and rendered presentation `content`:
+
+```ruby
+client = Slidict::Llm::Client.new(base_url: url, api_key: key, model: model)
+result = Slidict::Generator.new(client: client).generate(
+  text: article,
+  framework: "slidev",
+  language: "Japanese"
+)
+result.deck    # => Slidict::Deck
+result.content # => Slidev source
+```
+
 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:

data/lib/slidict/cli/app.rb

@@ -32,6 +32,8 @@ module Slidict
       flag "--duration",     arg: "TEXT",  desc: 'Presentation length, for example "5 minutes"'
       flag "--audience",     arg: "TEXT",  desc: "Target audience"
       flag "--goal",         arg: "TEXT",  desc: "Desired audience takeaway or action"
+      flag "--text",         arg: "TEXT",  desc: "Source text to turn into slides"
+      flag "--text-file",    arg: "PATH",  desc: "Read source text from a file"
       flag "--framework",    arg: "NAME",
                              desc: -> { "#{Output::Format.names.join(", ")} (default: slidev)\n(env: SLIDICT_FRAMEWORK)" }
       flag "--method",       arg: "ID",    desc: "Presentation method, for example scqa, prep, or pyramid\n" \
@@ -73,17 +75,23 @@ module Slidict
         config = build_config(options)
         return print_available_models(config) if config.llm_enabled? && config.model.nil?
 
+        # Validate and read local input before making a network request. This
+        # keeps missing/empty source-file errors fast and deterministic.
+        options[:text] = read_source_text(options)
         client = llm_client_for(config)
         return FAILURE if client && !verify_connection(client)
 
+        raise ArgumentError, "--text and --text-file require an LLM endpoint" if options[:text] && !client
+
         questions = questions_for(client, options)
         deck = Deck.new(
-          topic: ask(questions[:topic], options[:topic]),
-          duration: ask(questions[:duration], options[:duration]),
-          audience: ask(questions[:audience], options[:audience]),
-          goal: ask(questions[:goal], options[:goal]),
+          topic: source_topic(options) || ask(questions[:topic], options[:topic]),
+          duration: options[:text] ? options[:duration] : ask(questions[:duration], options[:duration]),
+          audience: options[:text] ? options[:audience] : ask(questions[:audience], options[:audience]),
+          goal: options[:text] ? options[:goal] : ask(questions[:goal], options[:goal]),
           framework: options[:framework],
-          presentation_method: options[:presentation_method]
+          presentation_method: options[:presentation_method],
+          source: options[:text]
         )
 
         if client
@@ -95,7 +103,8 @@ module Slidict
           end
           deck = Deck.new(
             topic: deck.topic, duration: deck.duration, audience: deck.audience, goal: deck.goal,
-            framework: deck.framework, slides: slides, presentation_method: deck.presentation_method
+            framework: deck.framework, slides: slides, presentation_method: deck.presentation_method,
+            source: deck.source
           )
         end
 
@@ -117,6 +126,28 @@ module Slidict
 
       private
 
+      def read_source_text(options)
+        raise ArgumentError, "specify only one of --text or --text-file" if options[:text] && options[:text_file]
+        unless options[:text_file]
+          raise ArgumentError, "source text must not be empty" if options.key?(:text) && options[:text].to_s.strip.empty?
+
+          return options[:text]
+        end
+
+        File.read(options[:text_file]).tap do |text|
+          raise ArgumentError, "source text must not be empty" if text.strip.empty?
+        end
+      rescue Errno::ENOENT, Errno::EACCES => e
+        raise ArgumentError, "could not read #{options[:text_file]}: #{e.message}"
+      end
+
+      def source_topic(options)
+        return options[:topic] unless options[:topic].to_s.strip.empty?
+        return unless options[:text]
+
+        options[:text].each_line.map(&:strip).find { |line| !line.empty? }&.sub(/\A#+\s*/, "")
+      end
+
       def parse(argv)
         options = { framework: ENV["SLIDICT_FRAMEWORK"] || "slidev", method: ENV["SLIDICT_METHOD"] }
         args = argv.dup
@@ -370,7 +401,10 @@ module Slidict
 
       def fetch_value!(args, option)
         value = args.shift
-        raise ArgumentError, "#{option} requires a value" if value.nil? || value.start_with?("-")
+        # Source prose can legitimately start with Markdown frontmatter or a
+        # list item. Other options retain the typo-friendly flag check.
+        missing = value.nil? || (value.start_with?("-") && option != "--text")
+        raise ArgumentError, "#{option} requires a value" if missing
 
         value
       end
@@ -389,6 +423,7 @@ module Slidict
       # left to ask, or a translation call fails -- this is a nicety, not
       # something worth aborting slide generation over.
       def questions_for(client, options)
+        return QUESTIONS if options[:text]
         return QUESTIONS unless client && options[:language]
 
         missing = QUESTIONS.select { |key, _| options[key].to_s.strip.empty? }

data/lib/slidict/deck.rb

@@ -4,15 +4,17 @@ module Slidict
   Slide = Struct.new(:title, :bullets, keyword_init: true)
 
   class Deck
-    attr_reader :topic, :duration, :audience, :goal, :framework, :presentation_method
+    attr_reader :topic, :duration, :audience, :goal, :framework, :presentation_method, :source
 
-    def initialize(topic:, duration:, audience:, goal:, framework: "slidev", slides: nil, presentation_method: nil)
+    def initialize(topic:, duration:, audience:, goal:, framework: "slidev", slides: nil, presentation_method: nil,
+                   source: 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
       @presentation_method = presentation_method
+      @source = source.to_s.strip
       @slides = slides
     end
 

data/lib/slidict/generator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Slidict
+  # Framework-independent application API for integrations such as slidict.io.
+  # It turns source prose into both a Deck and presentation source without
+  # involving CLI input/output or the filesystem.
+  class Generator
+    Result = Struct.new(:deck, :content, keyword_init: true)
+
+    def initialize(client:, renderer: Output::Renderer.new)
+      @client = client
+      @renderer = renderer
+    end
+
+    def generate(text:, topic: nil, duration: nil, audience: nil, goal: nil,
+                 framework: "slidev", language: nil, presentation_method: nil)
+      source = text.to_s.strip
+      raise ArgumentError, "text must not be empty" if source.empty?
+
+      deck = Deck.new(
+        topic: topic || title_from(source),
+        duration: duration,
+        audience: audience,
+        goal: goal || "communicate the source text clearly",
+        framework: framework,
+        presentation_method: presentation_method,
+        source: source
+      )
+      slides = @client.generate_slides(deck, language: language)
+      generated_deck = Deck.new(
+        topic: deck.topic, duration: deck.duration, audience: deck.audience, goal: deck.goal,
+        framework: deck.framework, slides: slides, presentation_method: deck.presentation_method,
+        source: source
+      )
+
+      Result.new(deck: generated_deck, content: @renderer.render(generated_deck))
+    end
+
+    private
+
+    def title_from(source)
+      source.each_line.map(&:strip).find { |line| !line.empty? }&.sub(/\A#+\s*/, "")
+    end
+  end
+end

data/lib/slidict/llm/client.rb

@@ -75,6 +75,7 @@ module Slidict
           Audience: #{deck.audience}
           Goal: #{deck.goal}
           #{method_prompt_for(deck)}
+          #{source_prompt_for(deck)}
 
           Return one slide for each required slide role when a presentation method is
           provided; otherwise return exactly 5 slides. Each item must be an object with
@@ -84,6 +85,19 @@ module Slidict
         PROMPT
       end
 
+      def source_prompt_for(deck)
+        return "" if deck.source.empty?
+
+        <<~SOURCE
+          Source text:
+          <source>
+          #{deck.source}
+          </source>
+          Base the presentation on the source text. Identify its central message,
+          preserve important facts and examples, and do not invent unsupported claims.
+        SOURCE
+      end
+
       def language_instruction_for(language)
         return "" unless language
 

data/lib/slidict/version.rb

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

data/lib/slidict.rb

@@ -20,6 +20,7 @@ require_relative "slidict/lint/slide_parser"
 require_relative "slidict/llm/client"
 require_relative "slidict/output/format"
 require_relative "slidict/output/renderer"
+require_relative "slidict/generator"
 require_relative "slidict/presentation_method"
 require_relative "slidict/version"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slidict
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.2
 platform: ruby
 authors:
 - Yusuke Abe
@@ -92,6 +92,7 @@ files:
 - lib/slidict/external/slidict_io/auth.rb
 - lib/slidict/external/slidict_io/client.rb
 - lib/slidict/external/slidict_io/credentials.rb
+- lib/slidict/generator.rb
 - lib/slidict/lint/finding.rb
 - lib/slidict/lint/linter.rb
 - lib/slidict/lint/renderer.rb