stream_weaver 0.3.0

data/lib/stream_weaver/components/deck/deck_summary.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    module Deck
+      # Auto-generated summary slide appended to the end of a design deck.
+      # Reads DeckState to display:
+      #   - Each slide's title, selected option label, aside text, and notes
+      #   - A "Still need: Slide X, Slide Y" message when selections are incomplete
+      #   - A final notes textarea for overall comments
+      #   - A Submit button gated on all slides having a selection
+      #
+      # Submit sets state[:_result] with { deck_selections: {...}, deck_notes: {...} }
+      # which triggers run_once! to unblock.
+      #
+      # sw- CSS classes:
+      #   sw-deck-summary              - summary slide wrapper
+      #   sw-deck-summary__title       - summary heading
+      #   sw-deck-summary__cards       - grid of summary cards
+      #   sw-deck-summary__card        - individual summary card
+      #   sw-deck-summary__card-title  - slide title in card
+      #   sw-deck-summary__card-label  - selected option label
+      #   sw-deck-summary__card-aside  - aside text
+      #   sw-deck-summary__card-notes  - notes text
+      #   sw-deck-summary__card--empty - card with no selection
+      #   sw-deck-summary__missing     - "still need" message
+      #   sw-deck-summary__final-notes - final notes textarea container
+      #   sw-deck-summary__submit      - submit button
+      #   sw-deck-summary__submit--disabled - disabled submit button
+      #
+      # @example Auto-appended by design_deck DSL method (no manual usage needed)
+      class DeckSummary < Base
+        attr_accessor :deck_slides
+
+        def initialize(**options)
+          @deck_slides = []
+          super(**options)
+        end
+
+        def render(view, state)
+          view.adapter.render_deck_summary(view, self, state)
+        end
+
+        # CSS class list
+        def css_classes
+          "sw-deck-summary"
+        end
+
+        # Check if all slides have selections
+        #
+        # @param deck_state [DeckState, nil] The deck state instance
+        # @return [Boolean] true if every slide has a selection
+        def all_selected?(deck_state)
+          return false unless deck_state
+          return true if @deck_slides.empty?
+
+          @deck_slides.all? { |slide| deck_state.selection(slide.id) }
+        end
+
+        # Get list of slide titles that still need selections
+        #
+        # @param deck_state [DeckState, nil] The deck state instance
+        # @return [Array<String>] titles of slides missing selections
+        def missing_slides(deck_state)
+          return @deck_slides.map { |s| s.title || s.id } unless deck_state
+
+          @deck_slides.reject { |slide| deck_state.selection(slide.id) }
+                      .map { |s| s.title || s.id }
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/deck/design_deck.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    module Deck
+      # Top-level orchestrator for a design deck.
+      # Contains DeckSlide children, wraps in SlideContainer with :swap mode,
+      # validates uniqueness of slide IDs, and auto-appends navigation.
+      #
+      # NOT an App subclass -- it is a component composed via DSL methods on App.
+      #
+      # sw- CSS classes:
+      #   sw-deck             - outermost deck wrapper
+      #   sw-deck__title      - deck title heading
+      #
+      # @example
+      #   design_deck "Architecture Direction" do
+      #     slide "arch", "System Architecture" do
+      #       option "Monolith" do
+      #         code_block "app.listen(3000)", lang: "ts"
+      #       end
+      #     end
+      #   end
+      class DesignDeck < Base
+        attr_reader :title
+        attr_accessor :children
+
+        # @param title [String] Deck title
+        # @param options [Hash] Additional options
+        def initialize(title, **options)
+          @title = title
+          @children = []
+          super(**options)
+        end
+
+        def render(view, state)
+          view.adapter.render_design_deck(view, self, state)
+        end
+
+        # Validate the deck structure.
+        # Raises if duplicate slide IDs are found.
+        def validate!
+          ids = @children
+            .select { |c| c.is_a?(DeckSlide) }
+            .map(&:id)
+
+          dupes = ids.group_by(&:itself).select { |_k, v| v.size > 1 }.keys
+          unless dupes.empty?
+            raise ArgumentError, "Duplicate slide IDs in design_deck: #{dupes.join(', ')}"
+          end
+        end
+
+        # CSS class list
+        def css_classes
+          "sw-deck"
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/deck/generate_more_controls.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    module Deck
+      # Generate-more controls rendered within a deck slide footer.
+      # Provides prompt input, count dropdown, generate/cancel buttons,
+      # and status display during generation.
+      #
+      # sw- CSS classes:
+      #   sw-generate-more                  - controls wrapper
+      #   sw-generate-more__form            - form with prompt + count + button
+      #   sw-generate-more__prompt          - prompt text input
+      #   sw-generate-more__count           - count dropdown
+      #   sw-generate-more__btn             - generate button
+      #   sw-generate-more__btn--cancel     - cancel button
+      #   sw-generate-more__status          - status banner during generation
+      #   sw-generate-more__status-dot      - animated pulse dot
+      #   sw-generate-more__status-text     - status text
+      #
+      # @example
+      #   GenerateMoreControls.new("arch", generate_state: gen_state)
+      class GenerateMoreControls < Base
+        attr_reader :slide_id
+
+        # @param slide_id [String] Slide this controls belong to
+        # @param generate_state [Hash] Current generation state from DeckState
+        # @param timeout [Integer] Timeout in seconds (default: 15)
+        def initialize(slide_id, generate_state: {}, timeout: 15, **options)
+          @slide_id = slide_id.to_s
+          @generate_state = generate_state
+          @timeout = timeout
+          super(**options)
+        end
+
+        def render(view, state)
+          view.adapter.render_generate_more_controls(view, self, state)
+        end
+
+        # Current generation status
+        # @return [Symbol] :idle, :generating, :timed_out, or :cancelled
+        def status
+          (@generate_state["status"] || "idle").to_sym
+        end
+
+        def generating?
+          status == :generating
+        end
+
+        def timed_out?
+          status == :timed_out
+        end
+
+        def requested_count
+          @generate_state["requested_count"] || 0
+        end
+
+        def received_count
+          @generate_state["received_count"] || 0
+        end
+
+        def remaining_count
+          generating? ? [requested_count - received_count, 0].max : 0
+        end
+
+        def prompt
+          @generate_state["prompt"]
+        end
+
+        def request_id
+          @generate_state["request_id"]
+        end
+
+        def timeout
+          @timeout
+        end
+
+        def css_classes
+          "sw-generate-more"
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/deck/model_selector.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    module Deck
+      # AI model picker for generate-more functionality.
+      # Renders provider filter pills and a model list.
+      # Selected model is stored in DeckState for use by generate-more.
+      #
+      # sw- CSS classes:
+      #   sw-model-selector              - outermost wrapper
+      #   sw-model-selector__pills       - provider filter pill row
+      #   sw-model-selector__pill        - individual provider pill
+      #   sw-model-selector__pill--active - active provider pill
+      #   sw-model-selector__list        - model list container
+      #   sw-model-selector__item        - individual model item
+      #   sw-model-selector__item--selected - selected model item
+      #   sw-model-selector__name        - model display name
+      #   sw-model-selector__provider    - model provider label
+      #
+      # @example
+      #   model_selector(
+      #     models: [
+      #       { id: "claude-3", name: "Claude 3 Opus", provider: "Anthropic" },
+      #       { id: "gpt-4", name: "GPT-4", provider: "OpenAI" }
+      #     ],
+      #     default_model: "claude-3"
+      #   )
+      class ModelSelector < Base
+        attr_reader :models, :default_model
+
+        # @param models [Array<Hash>] Array of { id:, name:, provider: } hashes
+        # @param default_model [String, nil] ID of the default selected model
+        # @param options [Hash] Additional options
+        def initialize(models: [], default_model: nil, **options)
+          @models = normalize_models(models)
+          @default_model = default_model || @models.first&.dig(:id)
+          super(**options)
+        end
+
+        def render(view, state)
+          view.adapter.render_model_selector(view, self, state)
+        end
+
+        # All unique provider names from the model list, sorted.
+        # @return [Array<String>]
+        def providers
+          @models.map { |m| m[:provider] }.uniq.sort
+        end
+
+        # Models filtered by provider (nil returns all).
+        # @param provider [String, nil] Provider name or nil for all
+        # @return [Array<Hash>]
+        def models_for_provider(provider)
+          return @models if provider.nil? || provider == "All"
+          @models.select { |m| m[:provider] == provider }
+        end
+
+        # Whether to show the selector (hidden when fewer than 2 models).
+        # @return [Boolean]
+        def visible?
+          @models.length >= 2
+        end
+
+        # CSS class list
+        def css_classes
+          "sw-model-selector"
+        end
+
+        private
+
+        def normalize_models(models)
+          models.map do |m|
+            {
+              id: (m[:id] || m["id"]).to_s,
+              name: (m[:name] || m["name"]).to_s,
+              provider: (m[:provider] || m["provider"]).to_s
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/deck/skeleton_placeholder.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    module Deck
+      # Shimmer animation placeholder shown while options are being generated.
+      # Rendered for (requested_count - received_count) placeholders.
+      #
+      # sw- CSS classes:
+      #   sw-skeleton                  - skeleton card wrapper
+      #   sw-skeleton__line            - shimmer line element
+      #   sw-skeleton__line--title     - wider title line
+      #   sw-skeleton__line--body      - narrower body line
+      #
+      # @example
+      #   SkeletonPlaceholder.new(index: 0)
+      class SkeletonPlaceholder < Base
+        attr_reader :index
+
+        # @param index [Integer] Index of this skeleton (for staggered animation)
+        def initialize(index: 0, **options)
+          @index = index
+          super(**options)
+        end
+
+        def render(view, state)
+          view.adapter.render_skeleton_placeholder(view, self, state)
+        end
+
+        def css_classes
+          "sw-skeleton"
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/diff_block.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Diffy shells out to the system diff(1) binary, so it exists only on the
+# server. In the browser the equivalent work is done by jsdiff -- see
+# #unified_diff below.
+require "diffy" unless RUBY_ENGINE == "opal"
+
+module StreamWeaver
+  module Components
+    # Unified diff viewer: removed lines red, added green, context neutral.
+    # Two-column line-number gutter (before | after). Prism.js highlights per-line
+    # fragments — multi-line constructs (heredocs, block comments) highlight each line
+    # independently, same limitation as AnnotatedCode.
+    class DiffBlock < Base
+      DiffLine = Struct.new(:type, :old_num, :new_num, :prefix, :content, keyword_init: true)
+
+      attr_accessor :before_code, :after_code
+      attr_reader :language
+
+      def initialize(language: nil, **options)
+        @language = language
+        @before_code = ""
+        @after_code = ""
+        @options = options
+      end
+
+      def language_class
+        language ? "language-#{language}" : "language-none"
+      end
+
+      def parsed_lines
+        before = before_code.to_s
+        after = after_code.to_s
+        return [] if before.empty? && after.empty?
+
+        before += "\n" unless before.end_with?("\n")
+        after  += "\n" unless after.end_with?("\n")
+
+        parse_unified_diff(unified_diff(before, after))
+      end
+
+      def render(view, state)
+        view.adapter.render_diff_block(view, self, state)
+      end
+
+      private
+
+      CONTEXT_LINES = 3
+
+      if RUBY_ENGINE == "opal"
+        # jsdiff, so the browser never needs a diff(1) binary it cannot have.
+        #
+        # structuredPatch rather than createPatch: the latter prepends an
+        # Index:/=== header that the server-side output has no equivalent for,
+        # and stripping a fixed number of lines back off is the kind of thing
+        # that breaks quietly. Building the unified text from the hunks keeps
+        # both engines feeding #parse_unified_diff the same shape.
+        #
+        # "" markers are dropped -- they are
+        # annotations rather than content, and parse_unified_diff would read
+        # the leading backslash as a context line.
+        def unified_diff(before, after)
+          # :nocov:
+          %x{
+            var patch = Diff.structuredPatch("", "", #{before}, #{after}, "", "",
+                                             { context: #{CONTEXT_LINES} });
+            var out = [];
+            patch.hunks.forEach(function(h) {
+              out.push("@@ -" + h.oldStart + "," + h.oldLines +
+                       " +" + h.newStart + "," + h.newLines + " @@");
+              h.lines.forEach(function(l) {
+                if (l.charAt(0) !== "\\\\") out.push(l);
+              });
+            });
+            return out.length ? out.join("\n") + "\n" : "";
+          }
+          # :nocov:
+        end
+      else
+        def unified_diff(before, after)
+          Diffy::Diff.new(before, after, context: CONTEXT_LINES).to_s(:text)
+        end
+      end
+
+      HUNK_HEADER_RE = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.freeze
+
+      def parse_unified_diff(text)
+        lines = []
+        old_line = 1
+        new_line = 1
+
+        text.each_line do |raw_line|
+          line = raw_line.chomp
+
+          if (m = HUNK_HEADER_RE.match(line))
+            old_line = m[1].to_i
+            new_line = m[2].to_i
+            lines << DiffLine.new(type: :hunk_header, old_num: nil, new_num: nil, prefix: "@@", content: line)
+            next
+          end
+
+          next if line.start_with?("---", "+++")
+
+          prefix = line[0] || " "
+          content = line[1..] || ""
+
+          case prefix
+          when "-"
+            lines << DiffLine.new(type: :removed, old_num: old_line, new_num: nil, prefix: "-", content: content)
+            old_line += 1
+          when "+"
+            lines << DiffLine.new(type: :added, old_num: nil, new_num: new_line, prefix: "+", content: content)
+            new_line += 1
+          else
+            lines << DiffLine.new(type: :context, old_num: old_line, new_num: new_line, prefix: " ", content: content)
+            old_line += 1
+            new_line += 1
+          end
+        end
+
+        lines
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/doc_header.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    # Document-level header with eyebrow label, serif title, and meta pill row.
+    # Used to open long-form documents: PRDs, reports, explainers.
+    #
+    # Pills are an array of mixed items:
+    #   - String → rendered as plain meta text
+    #   - Hash { text:, variant: } → colored pill (:default, :warn, :good)
+    #
+    # @example
+    #   doc_header(
+    #     eyebrow: "cultiv-ai · Personal OS",
+    #     title: "Calendar-Driven Travel State",
+    #     pills: [
+    #       { text: "Draft" },
+    #       "June 25, 2026",
+    #       "Author: Forrest Chang"
+    #     ]
+    #   )
+    class DocHeader < Base
+      attr_reader :eyebrow, :title, :pills
+
+      def initialize(eyebrow: nil, title:, pills: [], **options)
+        @eyebrow = eyebrow
+        @title = title
+        @pills = Array(pills)
+        @options = options
+      end
+
+      def render(view, state)
+        view.adapter.render_doc_header(view, self, state)
+      end
+    end
+
+    # Numbered section eyebrow + heading pair for document sections.
+    # Renders a monospace number badge and an h2 heading with a decorative line.
+    #
+    # @example
+    #   doc_section_header "01", "Problem Statement", id: "problem"
+    class DocSectionHeader < Base
+      attr_reader :number, :title, :anchor_id
+
+      def initialize(number, title, id: nil, **options)
+        @number = number.to_s
+        @title = title
+        @anchor_id = id
+        @options = options
+      end
+
+      def render(view, state)
+        view.adapter.render_doc_section_header(view, self, state)
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/image_block.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module StreamWeaver
+  module Components
+    # Image display component with optional caption and base64 export support.
+    #
+    # Renders an image with optional caption text below it.
+    # Supports local file paths, URLs, and base64 data URI conversion
+    # for self-contained HTML export.
+    #
+    # @example Basic usage
+    #   image_block("photo.png", alt: "A photo")
+    #
+    # @example With caption
+    #   image_block("diagram.svg", caption: "Figure 1: Architecture")
+    #
+    # @example Base64 export mode
+    #   image_block("local/image.png", base64: true)
+    class ImageBlock < Base
+      attr_reader :src, :alt, :caption, :base64
+
+      # @param src [String] Image source (URL or file path)
+      # @param alt [String] Alt text for accessibility (default: "")
+      # @param caption [String, nil] Caption text to display below the image
+      # @param base64 [Boolean] Convert local file to base64 data URI (default: false)
+      # @param options [Hash] Additional options
+      def initialize(src, alt: "", caption: nil, base64: false, **options)
+        @src = src.to_s
+        @alt = alt.to_s
+        @caption = caption
+        @base64 = base64
+        @options = options
+      end
+
+      # Resolve the image source, converting to data URI if base64 mode is enabled.
+      # @return [String] The resolved src attribute value
+      def resolved_src
+        return @src unless @base64 && File.exist?(@src)
+
+        mime = mime_type(@src)
+        data = Base64.strict_encode64(File.binread(@src))
+        "data:#{mime};base64,#{data}"
+      end
+
+      def render(view, state)
+        view.adapter.render_image_block(view, self, state)
+      end
+
+      private
+
+      # Detect MIME type from file extension
+      # @param path [String] File path
+      # @return [String] MIME type
+      def mime_type(path)
+        case File.extname(path).downcase
+        when ".png"  then "image/png"
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".gif"  then "image/gif"
+        when ".svg"  then "image/svg+xml"
+        when ".webp" then "image/webp"
+        when ".bmp"  then "image/bmp"
+        when ".ico"  then "image/x-icon"
+        else "application/octet-stream"
+        end
+      end
+    end
+  end
+end

data/lib/stream_weaver/components/implementation_map.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Components
+    # File-path-to-rationale mapping component for pre-flight planning.
+    # Shows what files will be touched and why, before writing any code.
+    #
+    # @example
+    #   implementation_map(files: [
+    #     { path: "lib/foo.rb", note: "Add the new method" },
+    #     { path: "spec/foo_spec.rb", note: "Cover edge cases" }
+    #   ])
+    class ImplementationMap < Base
+      attr_reader :files
+
+      # @param files [Array<Hash>] Array of {path:, note:} or {"path"=>,"note"=>} hashes
+      def initialize(files: [], **options)
+        @files = files.map { |f| normalize(f) }
+        @options = options
+      end
+
+      def render(view, state)
+        view.adapter.render_implementation_map(view, self, state)
+      end
+
+      private
+
+      def normalize(entry)
+        { path: entry[:path] || entry["path"] || "", note: entry[:note] || entry["note"] || "" }
+      end
+    end
+  end
+end