screenkit 0.0.0

data/lib/screenkit/callout/styles/inline_block.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "mini_magick"
+
+module ScreenKit
+  class Callout
+    module Styles
+      class InlineBlock < Base
+        extend SchemaValidator
+
+        attr_reader :background_color, :text_style, :body,
+                    :output_path, :padding, :text, :width, :source
+
+        def self.schema_path
+          ScreenKit.root_dir
+                   .join("screenkit/schemas/callouts/inline_block.json")
+        end
+
+        def initialize(source:, **kwargs) #  rubocop:disable Lint/MissingSuper
+          self.class.validate!(kwargs)
+
+          @source = source
+
+          # Set default values
+          kwargs = hi_res({
+            text_style: {size: 50, color: "#ffffff"}.merge(text_style || {}),
+            width: 600,
+            padding: [10, 10, 10, 10],
+            background_color: "#000000"
+          }.merge(kwargs))
+
+          kwargs.each do |key, value|
+            value = case key
+                    when :padding
+                      Spacing.new(value)
+                    when :text_style
+                      TextStyle.new(source:, **value)
+                    else
+                      value
+                    end
+
+            instance_variable_set(:"@#{key}", value)
+          end
+        end
+
+        def as_json(*)
+          {
+            background_color:,
+            text_style: text_style.as_json,
+            output_path:,
+            padding: padding.as_json,
+            text:,
+            width:
+          }
+        end
+
+        def render
+          padding_x = padding.horizontal
+          padding_y = padding.vertical
+          content_width = width - padding_x
+          lines = if text.include?("\n")
+                    text.lines.map(&:strip)
+                  else
+                    text_wrap(
+                      text,
+                      max_width: content_width,
+                      font_size: text_style.size
+                    )
+                  end
+
+          line_images = lines.map do |line|
+            render_text_image(
+              type: "label",
+              text: line,
+              style: text_style,
+              width: content_width
+            )
+          end
+
+          max_line_width = line_images.map {|_, w, _| w }.max || 0
+          height = line_images.sum {|_, _, h| h }
+
+          offset_y = 0
+          image_width = max_line_width + padding_x
+          image_height = (padding_y * lines.size) + height
+
+          MiniMagick.convert do |image|
+            # Create transparent canvas
+            image << "-size"
+            image << "#{image_width}x#{image_height}"
+            image << "xc:none"
+
+            line_images.each do |path, width, height|
+              # Draw rectangle background
+              image << "-fill"
+              image << background_color
+              image << "-draw"
+              image << "rectangle 0,#{offset_y}," \
+                       "#{width + padding_x}," \
+                       "#{offset_y + height + padding_y}"
+
+              # Composite line text
+              image << path
+              image << "-geometry"
+              image << "+#{padding.top}+#{offset_y + padding.left}"
+              image << "-composite"
+              offset_y += padding_y + height
+            end
+
+            image << "PNG:#{output_path}"
+          end
+
+          output_path
+        rescue MiniMagick::Error => error
+          retry if error.message.include?("No such file or directory")
+          raise
+        ensure
+          line_images&.each {|(path)| remove_file(path) }
+        end
+      end
+    end
+  end
+end

data/lib/screenkit/callout/text_style.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  class Callout
+    class TextStyle
+      attr_reader :color, :size, :font_path
+
+      def initialize(source:, **kwargs)
+        @source = source
+
+        kwargs.each do |key, value|
+          value = case key.to_sym
+                  when :font_path
+                    @source.search(value)
+                  else
+                    value
+                  end
+
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      # Convert hex color (with optional alpha) to RGB + opacity
+      # #RRGGBB or #RRGGBBAA
+      def rgb_color
+        color.match(/#([0-9a-fA-F]{6})/) {|m| m[1] }
+      end
+
+      def opacity
+        if color.length == 9
+          color.match(/#[0-9a-fA-F]{6}([0-9a-fA-F]{2})/) do |m|
+            m[1].to_i(16) / 255.0
+          end
+        else
+          1.0
+        end
+      end
+
+      def as_json(*)
+        {color:, size:, font_path:, rgb_color:, opacity:}
+      end
+    end
+  end
+end

data/lib/screenkit/callout.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  class Callout
+    using CoreExt
+
+    # Raised when a style class cannot be found
+    UndefinedStyleError = Class.new(StandardError)
+
+    extend SchemaValidator
+
+    # The callout anchor position. Should be an array with two elements:
+    #
+    # - Horizontal position: "left", "center", or "right"
+    # - Vertical position: "top", "center", or "bottom"
+    #
+    # @return [Array<String>] e.g., `["left", "bottom"]`
+    attr_reader :anchor
+
+    # The callout margin around the edges. Can be either a number, or an array
+    # with 1-4 elements, representing CSS-style margin values.
+    #
+    # - 1 value: all sides
+    # - 2 values: vertical | horizontal
+    # - 3 values: top | horizontal | bottom
+    # - 4 values: top | right | bottom | left
+    #
+    # @return [Array<Integer>, Integer] e.g., `20`, `[10, 20, 10, 20]`
+    attr_reader :margin
+
+    attr_accessor :in_transition, :out_transition, :style,
+                  :style_props, :style_class, :animation, :source, :log_path
+
+    def self.schema_path
+      ScreenKit.root_dir.join("screenkit/schemas/refs/callout.json")
+    end
+
+    def initialize(
+      source:,
+      animation:,
+      anchor:,
+      in_transition:,
+      out_transition:,
+      margin:,
+      style: "default",
+      log_path: nil,
+      **style_props
+    )
+      style_name = style || "default"
+
+      self.class.validate!(
+        animation:,
+        style: style_name,
+        anchor:,
+        in_transition:,
+        out_transition:,
+        margin:
+      )
+
+      @log_path = log_path
+      @source = source
+      @animation = animation
+      @style_class = resolve_style_class(style_name)
+      @anchor = Anchor.new(anchor)
+      @margin = Spacing.new(margin)
+      @in_transition = Transition.new(**in_transition)
+      @out_transition = Transition.new(**out_transition)
+      @style = style_class.new(source:, **style_props)
+    end
+
+    def render
+      if log_path
+        File.open(log_path, "w") do |f|
+          f << JSON.pretty_generate(
+            animation:,
+            anchor:,
+            margin:,
+            in_transition:,
+            out_transition:,
+            style:
+          )
+        end
+      end
+
+      style.render
+    end
+
+    def resolve_style_class(style)
+      error_message = "Style #{style.inspect} is not defined"
+
+      raise UndefinedStyleError, error_message unless style
+
+      Styles.const_get(style.split("_").map(&:capitalize).join)
+    rescue NameError
+      raise UndefinedStyleError, error_message
+    end
+  end
+end

data/lib/screenkit/cli/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module CLI
+    class Base < Thor
+      check_unknown_options!
+
+      class_option :config,
+                   type: :string,
+                   default: "screenkit.yml",
+                   desc: "Path to config file"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      no_commands do
+        def config
+          @config ||= Config::Project.load_file(options.config)
+        end
+      end
+    end
+  end
+end

data/lib/screenkit/cli/episode.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module CLI
+    class Episode < Base
+      namespace :episode
+      using CoreExt
+
+      desc "new", "Create a new episode"
+      option :title,
+             type: :string,
+             required: true,
+             desc: "Title of the episode"
+      def new
+        options = self.options.dup
+        episode_number = config.episode_dir.parent.glob("*").count(&:directory?)
+
+        dir = format(
+          config.episode_dir.basename.to_s,
+          episode_number: episode_number + 1,
+          episode_slug: options.title.dasherize,
+          date: Time.now.strftime("%Y-%m-%d")
+        )
+        options[:episode_dir] = config.episode_dir.parent.join(dir)
+
+        generator = Generators::Episode.new
+        generator.destination_root =
+          File.expand_path(File.dirname(options.config))
+        generator.options = options
+        generator.invoke_all
+      end
+
+      desc "export", "Export episode into a final video file"
+      option :dir,
+             type: :string,
+             required: true,
+             desc: "Directory of the episode to export"
+      option :voice_api_key,
+             type: :string,
+             desc: "API key for the voice synthesis service"
+      option :overwrite,
+             type: :boolean,
+             default: false,
+             desc: "Overwrite existing exported file"
+      option :match_segment,
+             type: :string,
+             desc: "Only export segments matching this string"
+      option :output_dir,
+             type: :string,
+             desc: "Path to save the exported video files"
+      option :banner,
+             type: :boolean,
+             default: true,
+             desc: "Display the ScreenKit banner"
+      option :require,
+             type: :array,
+             default: [],
+             desc: "Additional Ruby files to require"
+      def export
+        puts Banner.banner if options.banner
+
+        episode_config = Config::Episode.load_file(
+          File.join(options.dir, "config.yml")
+        )
+
+        options.require.each { require(it) }
+
+        exporter = ScreenKit::Exporter::Episode.new(
+          project_config: config,
+          config: episode_config,
+          options:
+        )
+
+        exporter.export
+      end
+    end
+  end
+end

data/lib/screenkit/cli/root.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module CLI
+    class Root < Base
+      desc "episode SUBCOMMAND", "Episode commands"
+      subcommand "episode", CLI::Episode
+
+      desc "new PATH", "Create a new project"
+      def new(path)
+        generator = Generators::Project.new
+        generator.destination_root = File.expand_path(path)
+        generator.options = options
+        generator.invoke_all
+      end
+
+      desc "callout", "Generate a callout PNG"
+      option :type,
+             type: :string,
+             required: true,
+             desc: "Callout type (e.g., info, warning)"
+      option :title,
+             type: :string,
+             required: true,
+             desc: "Callout title text"
+      option :body,
+             type: :string,
+             required: true,
+             desc: "Callout body text"
+      option :output,
+             type: :string,
+             desc: "Output path for PNG"
+      def callout
+        callout = config.callouts[options.type.to_sym]
+
+        unless callout
+          say "Callout type '#{options[:type]}' not found in config", :red
+          exit 1
+        end
+
+        output_path = options[:output]
+        output_path ||= Pathname(Tempfile.create(["callout-", ".png"]).path)
+
+        callout.render(
+          output_path:,
+          title: options.title,
+          body: options.body
+        )
+
+        puts output_path
+      end
+
+      desc "completion", "Generate shell completion script"
+      option :shell,
+             type: :string,
+             required: true,
+             enum: %w[bash zsh powershell fish]
+      def completion
+        puts Thor::Completion.generate(
+          name: "screenkit",
+          description: "Terminal to screencast, simplified",
+          version: VERSION,
+          cli: self.class,
+          shell: options.shell
+        )
+      end
+
+      no_commands do
+        # Add helper methods here
+      end
+    end
+  end
+end

data/lib/screenkit/cli.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module CLI
+    def self.start(args = ARGV)
+      Root.start(args)
+    end
+  end
+end

data/lib/screenkit/config/base.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module Config
+    class Base
+      extend SchemaValidator
+
+      def self.load_file(path)
+        unless File.file?(path)
+          raise FileNotFoundError, "Config file not found: #{path}"
+        end
+
+        config = YAML.load_file(path, symbolize_names: true)
+        load(config)
+      end
+
+      def self.load(config)
+        validate!(config)
+
+        new(**config)
+      end
+
+      def initialize(**kwargs)
+        kwargs.each do |key, value|
+          value = process(key, value)
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def process(_key, value)
+        value
+      end
+
+      def to_h
+        instance_variables.each_with_object({}) do |var, hash|
+          key = var.to_s.delete_prefix("@").to_sym
+          value = instance_variable_get(var)
+
+          hash[key] =
+            if value.respond_to?(:as_json)
+              value.as_json
+            elsif value.is_a?(Array)
+              value.map {|v| v.respond_to?(:as_json) ? v.as_json : v }
+            else
+              value
+            end
+        end
+      end
+    end
+  end
+end

data/lib/screenkit/config/episode.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module Config
+    class Episode < Base
+      # The scenes configuration for the episode.
+      attr_reader :scenes
+
+      # The title of the episode.
+      attr_reader :title
+
+      # The episode's TTS engine configuration.
+      attr_reader :tts
+
+      # The episode's backtrack music configuration.
+      attr_reader :backtrack
+
+      # The watermark configuration.
+      attr_reader :watermark
+
+      def self.schema_path
+        @schema_path ||=
+          ScreenKit.root_dir.join("screenkit/schemas/episode.json")
+      end
+
+      def initialize(**)
+        @scenes = {}
+
+        super
+      end
+
+      def process(key, value)
+        case key.to_sym
+        when /_(dir|path)$/
+          Pathname(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/screenkit/config/project.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module Config
+    class Project < Base
+      # The directory where episode source files are stored.
+      attr_reader :episode_dir
+
+      # The directory where resources files are stored.
+      attr_reader :resources_dir
+
+      # The output directory for exported files.
+      attr_reader :output_dir
+
+      # Callout configurations
+      attr_reader :callouts
+
+      # Scene configurations
+      attr_reader :scenes
+
+      # TTS configuration
+      attr_reader :tts
+
+      # The backtrack music configuration.
+      attr_reader :backtrack
+
+      # The watermark configuration.
+      attr_reader :watermark
+
+      def self.schema_path
+        @schema_path ||=
+          ScreenKit.root_dir.join("screenkit/schemas/project.json")
+      end
+
+      private def process(key, value)
+        case key.to_sym
+        when :resources_dir
+          Array(value)
+        when /_(dir|path)$/
+          Pathname(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/screenkit/content_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module ContentType
+    def self.video = %w[mp4 webm mov]
+    def self.audio = %w[mp3 wav m4a aac aiff]
+    def self.image = %w[gif jpg jpeg png]
+    def self.demotape = %w[tape]
+
+    def self.all = video + image + demotape
+  end
+end

data/lib/screenkit/core_ext/json.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module CoreExt
+    refine JSON.singleton_class do
+      def pretty_generate(target, *)
+        super(target.as_json, *)
+      end
+
+      def dump(target, *, **)
+        super(target.as_json, *, **)
+      end
+    end
+
+    refine Object do
+      def to_json(*)
+        if respond_to?(:as_json)
+          as_json(*).to_json
+        else
+          super
+        end
+      end
+
+      def as_json(*)
+        if respond_to?(:to_h)
+          to_h.transform_values { it.as_json(*) }
+        elsif respond_to?(:to_a)
+          to_a.map { it.as_json(*) }
+        else
+          self
+        end
+      end
+    end
+
+    refine Hash do
+      def as_json(*)
+        transform_values { it.as_json(*) }
+      end
+    end
+
+    refine Array do
+      def as_json(*)
+        map { it.as_json(*) }
+      end
+    end
+  end
+end

data/lib/screenkit/core_ext/string.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ScreenKit
+  module CoreExt
+    refine String do
+      def dasherize
+        unicode_normalize(:nfkd)
+          .delete("'")
+          .gsub(/[^\x00-\x7F]/, "")
+          .gsub(/[^-\w]+/xim, "-")
+          .tr("_", "-")
+          .gsub(/-+/xm, "-")
+          .gsub(/^-?(.*?)-?$/, '\1')
+          .downcase
+      end
+
+      def camelize(first_letter = :upper)
+        split(/_|-/).map.with_index do |part, index|
+          if index.zero? && first_letter == :lower
+            part.downcase
+          else
+            part.capitalize
+          end
+        end.join
+      end
+    end
+  end
+end