slidict 0.5.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc5350820094f49312526c30c254f437edd49374ac0202ba99067637a70dd331
-  data.tar.gz: 130980c85ff4a85a0189b95fddc825ea30eeae131e1549d83e80cee1ae5ba392
+  metadata.gz: ab47129a915cbf21d2a573c0f1d3f9f9b654eb86a6a4226261a94fc44a60ba16
+  data.tar.gz: f0ab819d3077c1bfa36f268dc06939c7f02bd483649be86d360d5558a2dded34
 SHA512:
-  metadata.gz: d27d844ad6ed53f6d860fe92e8614fad35e19caa10a9e5395b4eb6640c314a0224b0c32a5de612f13cababc8e438f61c1d6103d5a5c3a8133e2021eb67be6f73
-  data.tar.gz: 241380442ea402ed968bbd7829ec8ec49446f70d7f80852d75248a829d041b09d7a9c62d9ead1341d49e6dd5beff152340c7766f822bd064c29a1e0c407fb200
+  metadata.gz: 173dc71c06cf303b382fe7527ec27c8ddb61a9c3ced94563914fe2b56121af308b8d3f6290597800c32086d6ba6b51e8dc91dc1128a6776abf8358e0e1a113dc
+  data.tar.gz: e76f87bdd14452ce271dfa20cf5f8af65c5f82a3b687b53958d8e8a2cf45f022b79ba0ee2dd2dc753a02b1dcb44c4032bee8bfcebb2adbaf7512e77dcba7d68a

data/.github/pull_request_template.md

@@ -0,0 +1,22 @@
+## Summary
+
+<!-- What does this PR change, and why? -->
+
+## Version bump
+
+This repository follows [Semantic Versioning](https://semver.org/) (see `AGENTS.md`).
+Every PR is expected to update `lib/slidict/version.rb`, and CI fails when it does not.
+
+- [ ] <!-- skip-version-check --> This PR does not require a version bump
+
+<!--
+Leave the box above unchecked and bump `lib/slidict/version.rb` in this PR.
+Check it only when no release is needed (docs-only, CI-only, test-only changes, etc.).
+Keep the `skip-version-check` comment intact — the CI check looks for it.
+-->
+
+## Checklist
+
+- [ ] `bundle exec rspec` passes
+- [ ] `bundle exec rubocop` passes
+- [ ] `README.md` updated if user-facing behavior changed

data/.github/workflows/version-check.yml

@@ -0,0 +1,70 @@
+name: Version Check
+
+on:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - edited
+      - ready_for_review
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  version-file:
+    name: Require version.rb update
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Require version.rb update or an explicit skip
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          PR_BODY: ${{ github.event.pull_request.body }}
+          PR_ACTOR: ${{ github.event.pull_request.user.login }}
+          VERSION_FILE: lib/slidict/version.rb
+        run: |
+          set -euo pipefail
+
+          # Dependency update PRs are opened by bots that cannot fill in the
+          # pull request template, so they are exempt from this check.
+          case "$PR_ACTOR" in
+            'dependabot[bot]' | 'github-actions[bot]')
+              echo "::notice::Skipping version check for bot author '${PR_ACTOR}'."
+              exit 0
+              ;;
+          esac
+
+          # The pull request template ships a checkbox carrying the
+          # `skip-version-check` marker, unchecked by default.
+          if printf '%s\n' "${PR_BODY:-}" |
+            grep -qiE '^[[:space:]]*[-*+][[:space:]]+\[[[:space:]]*x[[:space:]]*\].*skip-version-check'; then
+            echo "::notice::'${VERSION_FILE}' is not required: the skip-version-check box is checked."
+            exit 0
+          fi
+
+          changed_files="$(gh api --paginate "repos/${REPO}/pulls/${PR_NUMBER}/files" --jq '.[].filename')"
+
+          if printf '%s\n' "$changed_files" | grep -qxF "$VERSION_FILE"; then
+            echo "::notice::'${VERSION_FILE}' is updated in this pull request."
+            exit 0
+          fi
+
+          echo "::error::'${VERSION_FILE}' is not updated in this pull request."
+          {
+            echo "### Version check failed"
+            echo
+            echo "This pull request does not update \`${VERSION_FILE}\`."
+            echo
+            echo "Do one of the following:"
+            echo
+            echo "- Bump \`VERSION\` in \`${VERSION_FILE}\` following [SemVer](https://semver.org/) (see \`AGENTS.md\`), or"
+            echo "- Check the \"This PR does not require a version bump\" box in the pull request description."
+            echo
+            echo "Editing the description re-runs this check automatically."
+          } >> "$GITHUB_STEP_SUMMARY"
+          exit 1

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.7.0] - 2026-07-30
+
+- Add built-in SDS, DESC, AIDMA, TAPS, and FABE presentation methods.
+- 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:
@@ -271,10 +299,12 @@ We optimize for communication, not decoration.
 
 ## Presentation methods
 
-Use `--method` to generate slides with a specific narrative structure, such as SCQA, PREP, or Pyramid Principle.
+Use `--method` to generate slides with a specific narrative structure. Built-in methods include SDS, PREP, DESC,
+AIDMA, TAPS, FABE, SCQA, and Pyramid Principle.
 
 ```bash
 bin/slidict --method scqa --topic "Database migration plan"
+bin/slidict --method aidma --topic "Product launch"
 bin/slidict list-methods
 bin/slidict show-method scqa
 ```

data/data/slidict/methods/aidma.yml

@@ -0,0 +1,35 @@
+id: aidma
+name: AIDMA
+category: marketing
+description: Attention, Interest, Desire, Memory, Action structure for guiding an audience from awareness to action.
+locale: en
+suitable_for:
+  - Marketing presentations
+  - Product and service pitches
+  - Campaign or launch proposals
+slides:
+  - title: Attention
+    role: Capture attention with an audience-relevant hook.
+    instructions: Open with a striking fact, question, or situation connected to the audience's needs.
+  - title: Interest
+    role: Build interest by showing why the subject is relevant.
+    instructions: Connect the offer or idea to a recognizable problem, opportunity, or aspiration.
+  - title: Desire
+    role: Turn interest into a preference for the proposed solution.
+    instructions: Show concrete benefits and help the audience imagine the improved outcome.
+  - title: Memory
+    role: Make the key message easy to recall.
+    instructions: Reinforce one distinctive promise with memorable evidence, phrasing, or imagery.
+  - title: Action
+    role: Prompt the audience to take a clear next step.
+    instructions: State one specific action, remove ambiguity, and explain what happens next.
+ai_instructions:
+  - Move through the AIDMA stages in order without asking for action too early.
+  - Frame benefits from the audience's point of view.
+  - Keep the memorable promise consistent with the evidence and call to action.
+review_checklist:
+  - Does the opening earn the target audience's attention?
+  - Does interest develop into a concrete desire?
+  - Is the central promise distinctive and memorable?
+  - Is the requested action specific and easy to understand?
+references: []

data/data/slidict/methods/desc.yml

@@ -0,0 +1,32 @@
+id: desc
+name: DESC
+category: assertive-communication
+description: Describe, Express, Specify, Consequences structure for proposing a constructive change or resolving conflict.
+locale: en
+suitable_for:
+  - Feedback and difficult conversations
+  - Conflict resolution
+  - Requests for behavioral or process change
+slides:
+  - title: Describe
+    role: Describe the situation or behavior objectively.
+    instructions: State observable facts without blame, assumptions, or judgment.
+  - title: Express
+    role: Explain the impact and the speaker's perspective or feelings.
+    instructions: Use specific first-person language to show why the situation matters.
+  - title: Specify
+    role: Request a concrete and achievable change.
+    instructions: Define the desired behavior, owner, and timing so the request is actionable.
+  - title: Consequences
+    role: Clarify the positive outcomes of the change and the implications of inaction.
+    instructions: Emphasize realistic benefits and consequences rather than threats.
+ai_instructions:
+  - Separate observable facts from interpretations and emotions.
+  - Keep the tone respectful, direct, and solution-oriented.
+  - Make the requested change specific enough to act on.
+review_checklist:
+  - Is the description factual and nonjudgmental?
+  - Is the impact expressed clearly from the speaker's perspective?
+  - Is the requested change concrete and achievable?
+  - Are the consequences realistic and constructive?
+references: []

data/data/slidict/methods/fabe.yml

@@ -0,0 +1,32 @@
+id: fabe
+name: FABE
+category: sales
+description: Features, Advantages, Benefits, Evidence structure for connecting an offering's capabilities to credible customer value.
+locale: en
+suitable_for:
+  - Sales presentations
+  - Product demonstrations
+  - Solution comparisons
+slides:
+  - title: Features
+    role: Introduce the relevant capabilities or attributes of the offering.
+    instructions: Select only features connected to the audience's needs and describe them precisely.
+  - title: Advantages
+    role: Explain how those features perform better or differently.
+    instructions: Compare the capabilities with the current approach or alternatives without unsupported claims.
+  - title: Benefits
+    role: Translate the advantages into outcomes the audience values.
+    instructions: State tangible functional or emotional value in the audience's terms.
+  - title: Evidence
+    role: Prove the promised benefits with credible support.
+    instructions: Use relevant data, demonstrations, testimonials, or case results and identify their context.
+ai_instructions:
+  - Maintain a clear chain from each feature to its advantage, benefit, and evidence.
+  - Prioritize audience value over a long inventory of specifications.
+  - Avoid claims that the evidence does not substantiate.
+review_checklist:
+  - Are the selected features relevant to the audience's needs?
+  - Are advantages differentiated clearly and fairly?
+  - Are benefits expressed as audience outcomes?
+  - Is every important claim supported by credible evidence?
+references: []

data/data/slidict/methods/sds.yml

@@ -0,0 +1,28 @@
+id: sds
+name: SDS
+category: concise-communication
+description: Summary, Details, Summary structure for communicating a message clearly and memorably.
+locale: en
+suitable_for:
+  - Short presentations and status updates
+  - Explanations that need a clear takeaway
+  - Messages for time-constrained audiences
+slides:
+  - title: Summary
+    role: State the central message or conclusion at the outset.
+    instructions: Give the audience a concise overview of what they should understand or remember.
+  - title: Details
+    role: Support the opening summary with the essential facts, reasoning, or examples.
+    instructions: Present only the details needed to substantiate the central message, in a logical order.
+  - title: Summary Revisited
+    role: Reinforce the central message after the supporting detail.
+    instructions: Restate the takeaway in fresh, concise language and connect it to the desired response.
+ai_instructions:
+  - Preserve the Summary, Details, Summary sequence.
+  - Keep the opening and closing summaries consistent while avoiding word-for-word repetition.
+  - Include only details that directly support the central message.
+review_checklist:
+  - Is the central message clear in the opening summary?
+  - Do all details support that message?
+  - Does the closing summary reinforce the intended takeaway?
+references: []

data/data/slidict/methods/taps.yml

@@ -0,0 +1,32 @@
+id: taps
+name: TAPS
+category: problem-solving
+description: To Be, As Is, Problem, Solution structure for defining a desired state and the change needed to reach it.
+locale: en
+suitable_for:
+  - Improvement proposals
+  - Transformation roadmaps
+  - Problem-solving presentations
+slides:
+  - title: To Be
+    role: Define the desired future state and its success criteria.
+    instructions: Describe a concrete, audience-relevant outcome rather than a vague aspiration.
+  - title: As Is
+    role: Establish the current state with objective evidence.
+    instructions: Show the present performance or behavior using facts that can be compared with the desired state.
+  - title: Problem
+    role: Identify the gap and the factors preventing progress.
+    instructions: Explain the most important root cause or barrier, not merely its symptoms.
+  - title: Solution
+    role: Present the actions that will close the gap.
+    instructions: Connect each proposed action to the identified problem and specify the immediate next step.
+ai_instructions:
+  - Make the gap between To Be and As Is explicit and measurable where possible.
+  - Distinguish root causes from symptoms.
+  - Ensure the solution directly addresses the stated problem.
+review_checklist:
+  - Is the desired state concrete and relevant?
+  - Is the current state supported by evidence?
+  - Does the problem explain the gap between the two states?
+  - Does the solution address the root cause and define a next step?
+references: []

data/docs/presentation-methods.md

@@ -10,11 +10,13 @@ gem only loads, validates, and applies that data.
 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 --method fabe --topic "Customer analytics platform"
 bin/slidict list-methods
 bin/slidict show-method scqa
 ```
 
-Built-in methods currently include SCQA, PREP, and Pyramid Principle.
+Built-in methods currently include SDS, PREP, DESC, AIDMA, TAPS, FABE, SCQA,
+and Pyramid Principle.
 
 ## Architecture
 
@@ -32,9 +34,14 @@ This keeps contribution review small: a new built-in method is usually one YAML
 
 ```text
 data/slidict/methods/
+  aidma.yml
+  desc.yml
+  fabe.yml
   prep.yml
   pyramid.yml
   scqa.yml
+  sds.yml
+  taps.yml
 lib/slidict/presentation_method.rb
 ```
 

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.7.0"
 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.7.0
 platform: ruby
 authors:
 - Yusuke Abe
@@ -60,11 +60,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/dependabot.yml"
+- ".github/pull_request_template.md"
 - ".github/release-drafter.yml"
 - ".github/workflows/bump-version.yml"
 - ".github/workflows/changelog.yml"
 - ".github/workflows/gem-push.yml"
 - ".github/workflows/test.yml"
+- ".github/workflows/version-check.yml"
 - AGENTS.md
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -72,9 +74,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- data/slidict/methods/aidma.yml
+- data/slidict/methods/desc.yml
+- data/slidict/methods/fabe.yml
 - data/slidict/methods/prep.yml
 - data/slidict/methods/pyramid.yml
 - data/slidict/methods/scqa.yml
+- data/slidict/methods/sds.yml
+- data/slidict/methods/taps.yml
 - docs/demo-methods.gif
 - docs/demo-methods.tape
 - docs/demo.gif
@@ -92,6 +99,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