slidict 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bb068dfb2e20826f82bc45f3fcdfbd6ae82017f40bff8ec64b44a52386475f9
-  data.tar.gz: 772140782502600fdce322609bf98e5f22c41c1f6306a8a92a954b84280eb2ff
+  metadata.gz: bcb8c90bc5cd08ea0215119e5b04eb6fbe7e9ed44c8ee5f6d5ef2a7aaaa884de
+  data.tar.gz: cef002ffa756fa6a30af65df47cd1c157ceb1187cc021b31ced01de41e73f2c1
 SHA512:
-  metadata.gz: 24c9549c8962cf8c6a8c2acfbe1f0ada4c761c59f33b3309354b17c58011aea56875352589b4db38a2f79955434c04f7061fc5e5208ca54233707bcc0981622e
-  data.tar.gz: 15f0400098c1ddf56b9fc0fc13f5bfa1385c6f3d6bfe001b799df1b7bbf415815d8af08b61664e123bb5aa9c477dccf7e629d72d40a475d4f3557e4d91b7aec6
+  metadata.gz: fa541a9126446303bf5e4b8ef0e1cc852311e6d1d9d022db1446594e49e76a7a56fd379100c727296c70cdf09c2379b954cb057cdea63902716d1d153573d58f
+  data.tar.gz: 9119b310faaa5442a01c716b79e804f9f5f9e90c2d9cd8cb06977905e9d976d45b915e2d1138775ddc36c8306c1528b96a8402e0e3045058d9c66d0c849da15d

data/AGENTS.md

@@ -39,3 +39,15 @@ Common types used in this repo:
 - `test:` adding or correcting tests
 
 Keep the summary short and in the imperative mood (e.g. `fix: handle empty topic input`).
+
+## Versioning (SemVer)
+
+This project follows [Semantic Versioning](https://semver.org/). For a CLI like slidict, apply these rules:
+
+| Change type | Version bump |
+|---|---|
+| Breaking change — existing commands, options, config format, or output parsing breaks | `MAJOR` (`1.x → 2.0.0`) |
+| Backward-compatible addition — new command, new option, new output field | `MINOR` (`1.2.x → 1.3.0`) |
+| Backward-compatible fix — bug fix, internal refactor, perf improvement, dependency update | `PATCH` (`1.2.3 → 1.2.4`) |
+
+While the project is at `0.x`, breaking changes may be released as `MINOR` bumps (e.g. `0.3.x → 0.4.0`) following common OSS convention.

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-07-01
+
+- Add data-driven presentation methods with SCQA, PREP, and Pyramid Principle templates.
+- Add `--method`, `list-methods`, and `show-method` CLI support.
+
+
 ## [0.1.0] - 2026-06-21
 
 - Initial release

data/README.md

@@ -225,3 +225,127 @@ We optimize for communication, not decoration.
 ## License
 
 MIT
+
+## Presentation methods
+
+Slidict supports data-driven presentation methods. A method defines the narrative
+technique, slide roles, AI instructions, and review checklist in YAML, while the Ruby
+gem only loads, validates, and applies that data.
+
+```bash
+bin/slidict new --method prep --topic "New onboarding flow"
+bin/slidict --method scqa --topic "Database migration plan"
+bin/slidict --method pyramid --topic "FY roadmap recommendation"
+bin/slidict list-methods
+bin/slidict show-method scqa
+```
+
+Built-in methods currently include SCQA, PREP, and Pyramid Principle.
+
+### Method architecture
+
+The method system is intentionally data-first:
+
+1. YAML files live in `data/slidict/methods/`.
+2. `Slidict::PresentationMethodRegistry` discovers built-in files and plugin-provided files.
+3. `Slidict::PresentationMethod` validates each YAML document and maps it to Ruby objects.
+4. `Slidict::Deck` uses the method's slide roles as the built-in non-LLM outline.
+5. `Slidict::Llm::Client` injects the method description, slide roles, and AI instructions into the generation prompt.
+
+This keeps contribution review small: a new built-in method is usually one YAML file and no Ruby code.
+
+### Directory structure
+
+```text
+data/slidict/methods/
+  prep.yml
+  pyramid.yml
+  scqa.yml
+lib/slidict/presentation_method.rb
+```
+
+For 100+ methods, keep one method per file and use stable lowercase IDs such as
+`scqa`, `prep`, `pyramid`, or `problem-solution`. Categories are free-form labels
+that can later drive filtering without changing the file layout.
+
+### YAML schema
+
+Each method file is a single YAML mapping:
+
+```yaml
+id: scqa
+name: SCQA
+category: narrative
+description: Situation, Complication, Question, Answer structure for building a clear business narrative.
+locale: en
+suitable_for:
+  - Strategy updates
+  - Problem-solving proposals
+slides:
+  - title: Situation
+    role: Establish the shared context the audience already recognizes.
+    instructions: Describe the current state with concrete facts.
+ai_instructions:
+  - Use the SCQA sequence exactly.
+review_checklist:
+  - Does the situation establish common ground?
+references:
+  - title: The Pyramid Principle
+    author: Barbara Minto
+```
+
+Required fields are `id`, `name`, `category`, `description`, `suitable_for`,
+`slides`, `ai_instructions`, and `review_checklist`. `references` and `locale` are
+optional; `locale` defaults to `en`. Every slide entry requires `title`, `role`, and
+`instructions`.
+
+### Ruby class design
+
+- `Slidict::PresentationMethod` represents one method definition.
+- `Slidict::MethodSlide` represents each slide role.
+- `Slidict::PresentationMethodRegistry` loads built-in YAML files and plugin YAML files.
+- `Slidict::Deck` accepts an optional `presentation_method` and turns method slide roles into a local template when `--no-llm` is used or no LLM is configured.
+
+Validation happens at load time with `YAML.safe_load_file`. Slidict checks required
+fields, requires lowercase method IDs (`a-z`, `0-9`, and `-`), and verifies that each
+slide role has the required fields.
+
+### CLI design
+
+- `--method ID` applies a method to generated slides.
+- `list-methods` prints every discovered method.
+- `show-method ID` prints a method's description, use cases, slide roles, and review checklist.
+
+### Plugin design
+
+External gems can distribute methods without changing Slidict itself. A plugin gem only
+needs to place YAML files under `lib/slidict/methods/*.yml` so RubyGems can expose them
+through `Gem.find_files`.
+
+Example plugin layout:
+
+```text
+slidict-methods-product/
+  lib/slidict/methods/product-demo.yml
+  slidict-methods-product.gemspec
+```
+
+After the plugin gem is installed, Slidict automatically includes those YAML files in
+`list-methods`, `show-method`, and `--method` lookup.
+
+### Future localization
+
+Method files include a `locale` field. The recommended future shape is one file per
+localized method, for example `scqa.en.yml` and `scqa.ja.yml`, with the same method ID
+plus locale-aware lookup. Keeping all user-facing text in YAML means translations can be
+reviewed independently from Ruby changes.
+
+### OSS contribution workflow
+
+To propose a new presentation method:
+
+1. Copy an existing YAML file in `data/slidict/methods/`.
+2. Change `id`, `name`, `category`, `description`, `suitable_for`, `slides`, `ai_instructions`, and `review_checklist`.
+3. Add `references` when useful.
+4. Run `bundle exec rspec` and `bundle exec rubocop`.
+5. Open a PR with the method file and a short explanation of the communication technique.

data/data/slidict/methods/prep.yml

@@ -0,0 +1,35 @@
+id: prep
+name: PREP
+category: persuasive
+description: Point, Reason, Example, Point structure for concise persuasive talks.
+locale: en
+suitable_for:
+  - Short recommendations
+  - Lightning talks
+  - Sales or product pitches
+slides:
+  - title: Point
+    role: State the main claim or recommendation immediately.
+    instructions: Open with the conclusion the audience should remember.
+  - title: Reason
+    role: Explain why the point is valid or important.
+    instructions: Give two or three audience-relevant reasons without overloading the slide.
+  - title: Example
+    role: Make the reason concrete with evidence, a case, or a scenario.
+    instructions: Use a specific example that proves the point in the audience's context.
+  - title: Point Revisited
+    role: Reinforce the original claim after the supporting material.
+    instructions: Restate the point with sharper wording and connect it to the desired action.
+  - title: Action
+    role: Ask the audience to decide, try, approve, or remember something.
+    instructions: End with a clear call to action and success criterion.
+ai_instructions:
+  - Put the conclusion before the explanation.
+  - Keep the example concrete enough that the audience can visualize it.
+  - Make the final point stronger, not merely repetitive.
+review_checklist:
+  - Is the opening point unmistakable?
+  - Do the reasons support the point rather than introduce new claims?
+  - Is the example specific and relevant?
+  - Does the closing restatement lead to action?
+references: []

data/data/slidict/methods/pyramid.yml

@@ -0,0 +1,41 @@
+id: pyramid
+name: Pyramid Principle
+category: executive-communication
+description: Top-down communication structure that starts with the governing thought and supports it with grouped arguments.
+locale: en
+suitable_for:
+  - Executive presentations
+  - Consulting-style recommendations
+  - Complex decisions with multiple supporting arguments
+slides:
+  - title: Governing Thought
+    role: Present the answer or recommendation first.
+    instructions: State the central message as a complete sentence, not a topic label.
+  - title: Key Line
+    role: Preview the small set of main arguments that support the governing thought.
+    instructions: Group supporting ideas into mutually distinct and collectively useful points.
+  - title: Argument 1
+    role: Develop the first supporting argument.
+    instructions: Explain the argument with evidence and show how it supports the governing thought.
+  - title: Argument 2
+    role: Develop the second supporting argument.
+    instructions: Explain the argument with evidence and avoid repeating Argument 1.
+  - title: Argument 3
+    role: Develop the third supporting argument or risk response.
+    instructions: Use this slide for a third pillar, trade-off, or objection handling.
+  - title: Synthesis
+    role: Reconnect the support to the recommendation and action.
+    instructions: Summarize the logic and ask for the specific decision or next step.
+ai_instructions:
+  - Start with the answer before details.
+  - Organize support into a clear hierarchy with parallel argument labels.
+  - Keep each argument distinct and tied back to the governing thought.
+review_checklist:
+  - Is the governing thought a complete answer?
+  - Are supporting arguments grouped logically?
+  - Are argument labels parallel and non-overlapping?
+  - Does every detail support a higher-level claim?
+  - Does the synthesis request a concrete decision or action?
+references:
+  - title: The Pyramid Principle
+    author: Barbara Minto

data/data/slidict/methods/scqa.yml

@@ -0,0 +1,38 @@
+id: scqa
+name: SCQA
+category: narrative
+description: Situation, Complication, Question, Answer structure for building a clear business narrative.
+locale: en
+suitable_for:
+  - Strategy updates
+  - Problem-solving proposals
+  - Executive briefings
+slides:
+  - title: Situation
+    role: Establish the shared context the audience already recognizes.
+    instructions: Describe the current state with concrete facts and avoid introducing the problem too early.
+  - title: Complication
+    role: Show what changed, broke, or created tension.
+    instructions: Explain why the current state is no longer sufficient and make the stakes explicit.
+  - title: Question
+    role: State the key decision or question the talk must answer.
+    instructions: Phrase the question from the audience's point of view.
+  - title: Answer
+    role: Present the core recommendation or conclusion.
+    instructions: Give the answer first, then support it with the strongest evidence.
+  - title: Next Steps
+    role: Convert the answer into action.
+    instructions: Close with the decision, owner, and immediate next step.
+ai_instructions:
+  - Use the SCQA sequence exactly and keep each slide focused on one narrative job.
+  - Make the answer concise enough to be repeated as a one-sentence takeaway.
+  - Prefer audience-relevant evidence over generic background.
+review_checklist:
+  - Does the situation establish common ground?
+  - Is the complication specific and consequential?
+  - Is the question explicit and audience-centered?
+  - Does the answer directly resolve the question?
+  - Are the next steps concrete?
+references:
+  - title: The Pyramid Principle
+    author: Barbara Minto

data/lib/slidict/cli/app.rb

@@ -26,6 +26,8 @@ module Slidict
         return slides(options[:args]) if options[:command] == "slides"
         return serve(options[:args]) if options[:command] == "serve"
         return lint(options[:args]) if options[:command] == "lint"
+        return list_methods if options[:command] == "list-methods"
+        return show_method(options[:args]) if options[:command] == "show-method"
 
         config = build_config(options)
         return print_available_models(config) if config.llm_enabled? && config.model.nil?
@@ -38,7 +40,8 @@ module Slidict
           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]
+          framework: options[:framework],
+          presentation_method: options[:presentation_method]
         )
 
         if client
@@ -50,7 +53,7 @@ module Slidict
           end
           deck = Deck.new(
             topic: deck.topic, duration: deck.duration, audience: deck.audience, goal: deck.goal,
-            framework: deck.framework, slides: slides
+            framework: deck.framework, slides: slides, presentation_method: deck.presentation_method
           )
         end
 
@@ -76,6 +79,8 @@ module Slidict
         options = { framework: "slidev" }
         args = argv.dup
 
+        args.shift if args.first == "new"
+
         if args.first == "auth"
           args.shift
           raise ArgumentError, "auth does not accept options" unless args.empty?
@@ -105,6 +110,21 @@ module Slidict
           return options
         end
 
+        if args.first == "list-methods"
+          args.shift
+          raise ArgumentError, "list-methods does not accept options" unless args.empty?
+
+          options[:command] = "list-methods"
+          return options
+        end
+
+        if args.first == "show-method"
+          args.shift
+          options[:command] = "show-method"
+          options[:args] = args
+          return options
+        end
+
         until args.empty?
           case (arg = args.shift)
           when "-h", "--help"
@@ -123,6 +143,8 @@ module Slidict
             options[:goal] = fetch_value!(args, arg)
           when "--framework"
             options[:framework] = fetch_value!(args, arg)
+          when "--method"
+            options[:method] = fetch_value!(args, arg)
           when "--llm-base-url"
             options[:llm_base_url] = fetch_value!(args, arg)
           when "--llm-api-key"
@@ -145,6 +167,7 @@ module Slidict
         end
 
         options[:output] ||= output_path_for(options[:framework], options[:filename])
+        options[:presentation_method] = method_for(options[:method])
         options
       end
 
@@ -228,6 +251,41 @@ module Slidict
         lint_command.run(args)
       end
 
+      def list_methods
+        method_registry.all.each do |method|
+          @output.puts format(
+            "%-12<id>s %-28<name>s %<category>s",
+            id: method.id, name: method.name, category: method.category
+          )
+        end
+        0
+      end
+
+      def show_method(args)
+        raise ArgumentError, "show-method requires a method id" if args.empty?
+        raise ArgumentError, "show-method accepts exactly one method id" unless args.size == 1
+
+        method = method_registry.fetch(args.first)
+        @output.puts "#{method.name} (#{method.id})"
+        @output.puts "Category: #{method.category}"
+        @output.puts "Description: #{method.description}"
+        @output.puts "Suitable for:"
+        method.suitable_for.each { |item| @output.puts "  - #{item}" }
+        @output.puts "Slides:"
+        method.slides.each_with_index { |slide, i| @output.puts "  #{i + 1}. #{slide.title}: #{slide.role}" }
+        @output.puts "Review checklist:"
+        method.review_checklist.each { |item| @output.puts "  - #{item}" }
+        0
+      end
+
+      def method_for(id)
+        id ? method_registry.fetch(id) : nil
+      end
+
+      def method_registry
+        @method_registry ||= PresentationMethodRegistry.new
+      end
+
       def publish_to_slidict(deck, content, options)
         slides_command.publish(
           id: options[:slide_id],
@@ -276,11 +334,13 @@ module Slidict
 
       def print_help
         @output.puts <<~HELP
-          Usage: slidict [options]
+          Usage: slidict [new] [options]
           Usage: slidict auth
           Usage: slidict slides <list|show|create|edit> [options]
           Usage: slidict serve [sinatra options]
           Usage: slidict lint <file> [options]
+          Usage: slidict list-methods
+          Usage: slidict show-method <id>
 
           Generate presentation source files from a short conversation.
 
@@ -290,6 +350,8 @@ module Slidict
             serve            Serve slide files from ./public with Sinatra
             lint             Check whether a slide deck's structure will land with its audience
                              (run `slidict lint -h` for details)
+            list-methods     List available presentation methods
+            show-method      Show details for one presentation method
 
           Options:
               --topic TEXT       Presentation topic
@@ -297,6 +359,7 @@ module Slidict
               --audience TEXT    Target audience
               --goal TEXT        Desired audience takeaway or action
               --framework NAME   #{Output::Format.names.join(", ")} (default: slidev)
+              --method ID        Presentation method, for example scqa, prep, or pyramid
               --filename NAME    File name under public/ (default: next sequential file)
               --llm-base-url URL OpenAI Compatible API base URL (env: SLIDICT_LLM_BASE_URL).
                                  When omitted, the built-in slide template is used instead.

data/lib/slidict/deck.rb

@@ -4,14 +4,15 @@ module Slidict
   Slide = Struct.new(:title, :bullets, keyword_init: true)
 
   class Deck
-    attr_reader :topic, :duration, :audience, :goal, :framework
+    attr_reader :topic, :duration, :audience, :goal, :framework, :presentation_method
 
-    def initialize(topic:, duration:, audience:, goal:, framework: "slidev", slides: nil)
+    def initialize(topic:, duration:, audience:, goal:, framework: "slidev", slides: nil, presentation_method: 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
       @slides = slides
     end
 
@@ -22,6 +23,8 @@ module Slidict
     private
 
     def default_slides
+      return method_slides if presentation_method
+
       [
         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"]),
@@ -31,6 +34,15 @@ module Slidict
       ]
     end
 
+    def method_slides
+      presentation_method.slides.map do |slide|
+        Slide.new(
+          title: slide.title,
+          bullets: [slide.role, slide.instructions, "Tie this slide to: #{goal}"]
+        )
+      end
+    end
+
     def normalize(value, fallback:)
       text = value.to_s.strip
       text.empty? ? fallback : text

data/lib/slidict/llm/client.rb

@@ -64,14 +64,34 @@ module Slidict
           Duration: #{deck.duration}
           Audience: #{deck.audience}
           Goal: #{deck.goal}
+          #{method_prompt_for(deck)}
 
-          Return exactly 5 slides as a JSON array. Each item must be an object with
+          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
           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 method_prompt_for(deck)
+        method = deck.presentation_method
+        return "" unless method
+
+        slides = method.slides.each_with_index.map do |slide, index|
+          "#{index + 1}. #{slide.title} — role: #{slide.role}; instructions: #{slide.instructions}"
+        end.join("\n")
+        instructions = method.ai_instructions.map { |item| "- #{item}" }.join("\n")
+        <<~METHOD
+          Presentation method: #{method.name} (#{method.id})
+          Method description: #{method.description}
+          Required slide roles:
+          #{slides}
+          Method-specific generation instructions:
+          #{instructions}
+        METHOD
+      end
+
       LINT_PROMPT_TEMPLATE = <<~PROMPT
         You are a presentation structure linter for tech talks and lightning talks.
         Your goal is not to judge how the slides look, but to diagnose whether the

data/lib/slidict/presentation_method.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Slidict
+  MethodSlide = Struct.new(:title, :role, :instructions, keyword_init: true)
+
+  class PresentationMethod
+    REQUIRED_FIELDS = %w[id name category description suitable_for slides ai_instructions review_checklist].freeze
+    REQUIRED_SLIDE_FIELDS = %w[title role instructions].freeze
+
+    attr_reader :id, :name, :category, :description, :suitable_for, :slides,
+                :ai_instructions, :review_checklist, :references, :locale, :source_path
+
+    def initialize(attributes, source_path: nil)
+      @source_path = source_path
+      @id = attributes.fetch("id")
+      @name = attributes.fetch("name")
+      @category = attributes.fetch("category")
+      @description = attributes.fetch("description")
+      @suitable_for = Array(attributes.fetch("suitable_for"))
+      @slides = Array(attributes.fetch("slides")).map do |slide|
+        MethodSlide.new(
+          title: slide.fetch("title"),
+          role: slide.fetch("role"),
+          instructions: slide.fetch("instructions")
+        )
+      end
+      @ai_instructions = Array(attributes.fetch("ai_instructions"))
+      @review_checklist = Array(attributes.fetch("review_checklist"))
+      @references = Array(attributes["references"])
+      @locale = attributes.fetch("locale", "en")
+    end
+
+    def self.load_file(path)
+      attributes = YAML.safe_load_file(path, permitted_classes: [], aliases: false)
+      validate!(attributes, path)
+      new(attributes, source_path: path)
+    rescue Psych::Exception, KeyError, TypeError => e
+      raise ArgumentError, "invalid presentation method #{path}: #{e.message}"
+    end
+
+    def self.validate!(attributes, path)
+      raise ArgumentError, "#{path} must contain a YAML mapping" unless attributes.is_a?(Hash)
+
+      missing = REQUIRED_FIELDS.reject { |field| present?(attributes[field]) }
+      raise ArgumentError, "#{path} is missing required fields: #{missing.join(', ')}" unless missing.empty?
+
+      unless attributes["id"].is_a?(String) && attributes["id"].match?(/\A[a-z0-9-]+\z/)
+        raise ArgumentError, "#{path} id must be a string using lowercase letters, numbers, and hyphens"
+      end
+      raise ArgumentError, "#{path} slides must be a non-empty array" unless attributes["slides"].is_a?(Array) && !attributes["slides"].empty?
+
+      attributes["slides"].each_with_index do |slide, index|
+        unless slide.is_a?(Hash)
+          raise ArgumentError, "#{path} slide #{index + 1} must be a mapping"
+        end
+
+        missing_slide = REQUIRED_SLIDE_FIELDS.reject { |field| present?(slide[field]) }
+        next if missing_slide.empty?
+
+        raise ArgumentError, "#{path} slide #{index + 1} is missing required fields: #{missing_slide.join(', ')}"
+      end
+    end
+
+    def self.present?(value)
+      case value
+      when String then !value.strip.empty?
+      when Array then !value.empty?
+      else !value.nil?
+      end
+    end
+  end
+
+  class PresentationMethodRegistry
+    BUILTIN_GLOB = File.expand_path("../../data/slidict/methods/*.yml", __dir__)
+    PLUGIN_GLOB = "slidict/methods/*.yml"
+
+    def initialize(paths: nil, include_plugins: true)
+      @paths = paths || default_paths(include_plugins: include_plugins)
+    end
+
+    def all
+      @all ||= @paths.sort.map { |path| PresentationMethod.load_file(path) }.sort_by(&:id)
+    end
+
+    def find(id)
+      all.find { |method| method.id == id.to_s }
+    end
+
+    def fetch(id)
+      find(id) || raise(ArgumentError, "unknown presentation method #{id}")
+    end
+
+    private
+
+    def default_paths(include_plugins:)
+      paths = Dir[BUILTIN_GLOB]
+      paths += Gem.find_files(PLUGIN_GLOB) if include_plugins
+      paths.uniq
+    end
+  end
+end

data/lib/slidict/version.rb

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

data/lib/slidict.rb

@@ -18,6 +18,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/presentation_method"
 require_relative "slidict/version"
 
 module Slidict

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slidict
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Yusuke Abe
@@ -72,6 +72,9 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- data/slidict/methods/prep.yml
+- data/slidict/methods/pyramid.yml
+- data/slidict/methods/scqa.yml
 - lib/slidict.rb
 - lib/slidict/cli/app.rb
 - lib/slidict/cli/lint.rb
@@ -89,6 +92,7 @@ files:
 - lib/slidict/llm/client.rb
 - lib/slidict/output/format.rb
 - lib/slidict/output/renderer.rb
+- lib/slidict/presentation_method.rb
 - lib/slidict/version.rb
 homepage: https://labs.slidict.io/slidict/
 licenses: