ace-demo 0.18.0

data/lib/ace/demo/molecules/gh_asset_uploader.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tmpdir"
+require "fileutils"
+
+module Ace
+  module Demo
+    module Molecules
+      class GhAssetUploader
+        RELEASE_TAG = "demo-assets"
+        RELEASE_TITLE = "Demo Assets"
+        RELEASE_NOTES = "Auto-generated release for demo GIF hosting"
+
+        def initialize(now: -> { Time.now.to_i }, gh_bin: "gh")
+          @now = now
+          @gh_bin = gh_bin
+        end
+
+        def upload(file_path:, dry_run: false)
+          raise ArgumentError, "Recording file not found: #{file_path}" unless File.exist?(file_path)
+
+          asset_name = stamped_asset_name(file_path)
+          if dry_run
+            repo = ENV.fetch("GITHUB_REPOSITORY", "OWNER/REPO")
+            asset_url = "https://github.com/#{repo}/releases/download/#{RELEASE_TAG}/#{asset_name}"
+            return {asset_name: asset_name, asset_url: asset_url, dry_run: true}
+          end
+
+          repo = repo_name_with_owner
+          asset_url = "https://github.com/#{repo}/releases/download/#{RELEASE_TAG}/#{asset_name}"
+
+          ensure_release_exists!
+
+          Dir.mktmpdir("ace_demo_attach") do |tmpdir|
+            upload_path = File.join(tmpdir, asset_name)
+            FileUtils.cp(file_path, upload_path)
+            run_gh!("release", "upload", RELEASE_TAG, upload_path, "--clobber")
+          end
+
+          {asset_name: asset_name, asset_url: asset_url, dry_run: false}
+        end
+
+        private
+
+        def stamped_asset_name(file_path)
+          ext = File.extname(file_path)
+          base = File.basename(file_path, ext)
+          "#{base}-#{@now.call}#{ext}"
+        end
+
+        def repo_name_with_owner
+          stdout, stderr, status = Open3.capture3(@gh_bin, "repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner")
+          raise_auth_if_needed!(stderr)
+          raise GhCommandError, "Failed to detect repository: #{stderr.strip}" unless status.success?
+
+          repo = stdout.strip
+          raise GhCommandError, "Failed to detect repository" if repo.empty?
+
+          repo
+        end
+
+        def ensure_release_exists!
+          _stdout, stderr, status = Open3.capture3(@gh_bin, "release", "view", RELEASE_TAG)
+          raise_auth_if_needed!(stderr)
+          return if status.success?
+
+          return create_release! if stderr.downcase.include?("not found") || stderr.downcase.include?("could not find")
+
+          raise GhUploadError, "Failed to check release '#{RELEASE_TAG}': #{stderr.strip}"
+        end
+
+        def create_release!
+          run_gh!("release", "create", RELEASE_TAG, "--title", RELEASE_TITLE, "--notes", RELEASE_NOTES)
+        end
+
+        def run_gh!(*args)
+          _stdout, stderr, status = Open3.capture3(@gh_bin, *args)
+          raise_auth_if_needed!(stderr)
+          return if status.success?
+
+          raise GhUploadError, "gh #{args.join(" ")} failed: #{stderr.strip}"
+        end
+
+        def raise_auth_if_needed!(stderr)
+          return unless auth_error?(stderr)
+
+          raise GhAuthenticationError, "gh CLI not authenticated. Run: gh auth login"
+        end
+
+        def auth_error?(stderr)
+          text = stderr.to_s.downcase
+          text.include?("gh auth login") ||
+            text.include?("not logged into any github hosts") ||
+            text.include?("authentication required") ||
+            text.include?("authentication token")
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/inline_recorder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "ace/b36ts"
+require_relative "../atoms/demo_name_sanitizer"
+
+module Ace
+  module Demo
+    module Molecules
+      class InlineRecorder
+        def initialize(
+          executor: VhsExecutor.new,
+          output_dir: Demo.config["output_dir"],
+          vhs_bin: Demo.config["vhs_bin"]
+        )
+          @executor = executor
+          @output_dir = output_dir || ".ace-local/demo"
+          @vhs_bin = vhs_bin || "vhs"
+        end
+
+        def record(name:, commands:, format: "gif", output: nil, description: nil, tags: nil,
+          font_size: 16, width: 960, height: 480, timeout: "2s")
+          safe_name = Atoms::DemoNameSanitizer.sanitize(name)
+          session_id = generate_session_id
+          session_dir = File.expand_path(File.join(@output_dir, session_id), Dir.pwd)
+          tape_path = File.join(session_dir, "#{safe_name}.tape")
+          output_path = output ? File.expand_path(output, Dir.pwd) : File.join(session_dir, "#{safe_name}.#{format}")
+
+          content = Atoms::TapeContentGenerator.generate(
+            name: safe_name,
+            commands: commands,
+            description: description,
+            tags: tags,
+            output_path: "./#{safe_name}.#{format}",
+            font_size: font_size,
+            width: width,
+            height: height,
+            timeout: timeout
+          )
+
+          FileUtils.mkdir_p(session_dir)
+          File.write(tape_path, content)
+
+          cmd = Atoms::VhsCommandBuilder.build(
+            tape_path: tape_path,
+            output_path: output_path,
+            vhs_bin: @vhs_bin
+          )
+          @executor.run(cmd)
+
+          {output_path: output_path, tape_path: tape_path, session_dir: session_dir}
+        end
+
+        private
+
+        def generate_session_id
+          Ace::B36ts.now
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/media_retimer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+require "fileutils"
+
+module Ace
+  module Demo
+    module Molecules
+      class MediaRetimer
+        def initialize(ffmpeg_bin: "ffmpeg")
+          @ffmpeg_bin = ffmpeg_bin
+        end
+
+        def retime(input_path:, speed:, output_path: nil, dry_run: false)
+          raise ArgumentError, "Input file not found: #{input_path}" unless File.exist?(input_path)
+
+          parsed = Atoms::PlaybackSpeedParser.parse(speed)
+          raise ArgumentError, "Playback speed is required." unless parsed
+
+          target_path = output_path || default_output_path(input_path, parsed[:label])
+          return {input_path: input_path, output_path: target_path, speed: parsed[:label], dry_run: true} if dry_run
+
+          ensure_ffmpeg_available!
+          FileUtils.mkdir_p(File.dirname(target_path))
+
+          cmd = build_ffmpeg_command(
+            input_path: input_path,
+            output_path: target_path,
+            factor: parsed[:factor]
+          )
+          _stdout, stderr, status = Open3.capture3(*cmd)
+          raise MediaRetimeError, "FFmpeg retime failed: #{stderr.strip}" unless status.success?
+
+          {input_path: input_path, output_path: target_path, speed: parsed[:label], dry_run: false}
+        rescue Errno::ENOENT
+          raise FfmpegNotFoundError, "FFmpeg not found. Install ffmpeg to use retime."
+        end
+
+        private
+
+        def ensure_ffmpeg_available!
+          _stdout, _stderr, status = Open3.capture3(@ffmpeg_bin, "-version")
+          return if status.success?
+
+          raise FfmpegNotFoundError, "FFmpeg not found. Install ffmpeg to use retime."
+        rescue Errno::ENOENT
+          raise FfmpegNotFoundError, "FFmpeg not found. Install ffmpeg to use retime."
+        end
+
+        def default_output_path(input_path, speed_label)
+          path = Pathname.new(input_path)
+          ext = path.extname.downcase
+          basename = path.basename(ext).to_s
+          File.join(path.dirname.to_s, "#{basename}-#{speed_label}#{ext}")
+        end
+
+        def build_ffmpeg_command(input_path:, output_path:, factor:)
+          case File.extname(input_path).downcase
+          when ".gif"
+            [
+              @ffmpeg_bin, "-y", "-i", input_path,
+              "-filter_complex",
+              "[0:v]setpts=PTS/#{factor},split[v][p];[p]palettegen=stats_mode=full[pal];[v][pal]paletteuse=dither=bayer",
+              output_path
+            ]
+          when ".mp4", ".webm"
+            [
+              @ffmpeg_bin, "-y", "-i", input_path,
+              "-filter:v", "setpts=PTS/#{factor}",
+              "-an",
+              output_path
+            ]
+          else
+            raise ArgumentError, "Unsupported media format: #{File.extname(input_path)}. Use gif, mp4, or webm."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/tape_resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ace
+  module Demo
+    module Molecules
+      class TapeResolver
+        def initialize(gem_root: Demo.gem_root, home_dir: Dir.home, cwd: Dir.pwd)
+          @gem_root = gem_root
+          @home_dir = home_dir
+          @cwd = cwd
+        end
+
+        def resolve(tape_ref)
+          direct_path = File.expand_path(tape_ref, @cwd)
+          return direct_path if File.file?(direct_path)
+
+          candidates = search_dirs.map do |dir|
+            candidate_names(tape_ref).map { |name| File.join(dir, name) }
+          end
+          candidates.flatten!
+
+          match = candidates.find { |path| File.file?(path) }
+          return match if match
+
+          raise TapeNotFoundError, missing_message(tape_ref)
+        end
+
+        def search_dirs
+          Atoms::TapeSearchDirs.build(cwd: @cwd, home_dir: @home_dir, gem_root: @gem_root)
+        end
+
+        private
+
+        def candidate_names(tape_ref)
+          return [tape_ref] if explicit_filename?(tape_ref)
+
+          ["#{tape_ref}.tape.yml", "#{tape_ref}.tape.yaml", "#{tape_ref}.tape"]
+        end
+
+        def explicit_filename?(tape_ref)
+          tape_ref.end_with?(".tape", ".tape.yml", ".tape.yaml", ".yml", ".yaml")
+        end
+
+        def missing_message(tape_ref)
+          searched = search_dirs.join(", ")
+          "Tape not found: #{tape_ref}\nSearched: #{searched}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/tape_scanner.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Ace
+  module Demo
+    module Molecules
+      class TapeScanner
+        def initialize(gem_root: Demo.gem_root, home_dir: Dir.home, cwd: Dir.pwd, parser: Atoms::TapeMetadataParser)
+          @gem_root = gem_root
+          @home_dir = home_dir
+          @cwd = cwd
+          @parser = parser
+        end
+
+        def list
+          discovered = {}
+
+          search_dirs.each do |dir|
+            next unless Dir.exist?(dir)
+
+            discover_paths(dir).each do |path|
+              name = logical_name(path)
+              next if discovered.key?(name)
+
+              discovered[name] = build_record(name, path)
+            end
+          end
+
+          discovered.keys.sort.map { |name| discovered[name] }
+        end
+
+        def find(tape_ref)
+          direct_path = File.expand_path(tape_ref, @cwd)
+          if File.exist?(direct_path) && File.file?(direct_path)
+            name = logical_name(direct_path)
+            return build_record(name, direct_path)
+          end
+
+          lookup_name = logical_name(tape_ref)
+          match = find_in_search_dirs(lookup_name, tape_ref)
+          return match if match
+
+          raise TapeNotFoundError, missing_message(tape_ref)
+        end
+
+        private
+
+        def search_dirs
+          Atoms::TapeSearchDirs.build(cwd: @cwd, home_dir: @home_dir, gem_root: @gem_root)
+        end
+
+        def discover_paths(dir)
+          patterns = [File.join(dir, "*.tape.yml"), File.join(dir, "*.tape.yaml"), File.join(dir, "*.tape")]
+          patterns.flat_map { |pattern| Dir.glob(pattern).sort }
+        end
+
+        def build_record(name, path)
+          content = File.read(path)
+          format = path.end_with?(".tape.yml", ".tape.yaml") ? "yaml" : "tape"
+          metadata = extract_metadata(path: path, content: content, format: format)
+
+          {
+            name: name,
+            path: path,
+            display_path: display_path(path),
+            source: "#{display_path(File.dirname(path))}/",
+            format: format,
+            metadata: metadata,
+            description: metadata["description"],
+            content: content
+          }
+        end
+
+        def extract_metadata(path:, content:, format:)
+          return @parser.parse(content) if format == "tape"
+
+          spec = Atoms::DemoYamlParser.parse_file(path)
+          {
+            "description" => spec["description"],
+            "tags" => spec["tags"],
+            "settings" => spec["settings"],
+            "scene_names" => spec.fetch("scenes", []).map { |scene| scene["name"] }.compact
+          }
+        rescue DemoYamlParseError => e
+          {"description" => nil, "parse_error" => e.message}
+        end
+
+        def find_in_search_dirs(name, tape_ref)
+          explicit = explicit_filename?(tape_ref)
+          candidates = if explicit
+            [tape_ref]
+          else
+            ["#{name}.tape.yml", "#{name}.tape.yaml", "#{name}.tape"]
+          end
+
+          search_dirs.each do |dir|
+            candidates.each do |filename|
+              path = File.join(dir, filename)
+              next unless File.file?(path)
+
+              return build_record(logical_name(path), path)
+            end
+          end
+
+          nil
+        end
+
+        def explicit_filename?(tape_ref)
+          tape_ref.end_with?(".tape", ".tape.yml", ".tape.yaml", ".yml", ".yaml")
+        end
+
+        def logical_name(path)
+          File.basename(path).sub(/\.tape\.ya?ml\z/, "").sub(/\.tape\z/, "").sub(/\.ya?ml\z/, "")
+        end
+
+        def display_path(path)
+          expanded = File.expand_path(path)
+
+          if inside?(expanded, @cwd)
+            relative_to(@cwd, expanded)
+          elsif inside?(expanded, @gem_root)
+            relative_to(@gem_root, expanded)
+          elsif inside?(expanded, @home_dir)
+            relative_to(@home_dir, expanded, "~")
+          else
+            expanded
+          end
+        end
+
+        def relative_to(base, path, prefix = nil)
+          suffix = path.delete_prefix("#{File.expand_path(base)}/")
+          return suffix if prefix.nil?
+
+          [prefix, suffix].join("/")
+        end
+
+        def inside?(path, base)
+          path == File.expand_path(base) || path.start_with?("#{File.expand_path(base)}/")
+        end
+
+        def missing_message(tape_ref)
+          names = list.map { |item| item[:name] }
+          available = names.empty? ? "(none)" : names.join(", ")
+          "Tape not found: #{tape_ref}\nAvailable tapes: #{available}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/tape_writer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ace
+  module Demo
+    module Molecules
+      class TapeWriter
+        def initialize(cwd: Dir.pwd)
+          @cwd = cwd
+        end
+
+        def write(name:, content:, force: false, extension: ".tape")
+          path = tape_path(name, extension: extension)
+
+          if File.exist?(path) && !force
+            raise TapeAlreadyExistsError, "Tape already exists: #{path}\nUse --force to overwrite."
+          end
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, content)
+
+          path
+        end
+
+        private
+
+        def tape_path(name, extension:)
+          File.join(@cwd, ".ace", "demo", "tapes", "#{name}#{extension}")
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/vhs_executor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Ace
+  module Demo
+    module Molecules
+      class VhsExecutor
+        INSTALL_URL = "https://github.com/charmbracelet/vhs"
+
+        def vhs_available?(vhs_bin: "vhs")
+          _stdout, _stderr, status = Open3.capture3(vhs_bin, "--version")
+          status.success?
+        rescue Errno::ENOENT
+          false
+        end
+
+        def run(cmd, vhs_bin: "vhs", chdir: nil)
+          options = {}
+          options[:chdir] = chdir if chdir
+          stdout, stderr, status = Open3.capture3(*cmd, **options)
+          result = Models::ExecutionResult.new(
+            stdout: stdout.strip,
+            stderr: stderr.strip,
+            success: status.success?,
+            exit_code: status.exitstatus
+          )
+
+          return result if result.success?
+
+          raise VhsExecutionError, "VHS execution failed: #{result.stderr}"
+        rescue Errno::ENOENT
+          raise VhsNotFoundError, "VHS not found. Install: #{INSTALL_URL}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/organisms/demo_attacher.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ace
+  module Demo
+    module Organisms
+      class DemoAttacher
+        def initialize(uploader: Molecules::GhAssetUploader.new,
+          formatter: Atoms::DemoCommentFormatter,
+          poster: Molecules::DemoCommentPoster.new,
+          clock: -> { Time.now })
+          @uploader = uploader
+          @formatter = formatter
+          @poster = poster
+          @clock = clock
+        end
+
+        def attach(file:, pr:, dry_run: false)
+          raise ArgumentError, "Recording file not found: #{file}" unless File.exist?(file)
+
+          demo_name = File.basename(file, File.extname(file))
+          ext = File.extname(file).delete_prefix(".").downcase
+          upload = @uploader.upload(file_path: file, dry_run: dry_run)
+          comment_body = @formatter.format(
+            demo_name: demo_name,
+            asset_url: upload.fetch(:asset_url),
+            recorded_at: @clock.call,
+            format: ext
+          )
+
+          @poster.post(pr: pr, comment_body: comment_body, dry_run: dry_run)
+
+          {
+            dry_run: dry_run,
+            pr: pr,
+            demo_name: demo_name,
+            asset_name: upload.fetch(:asset_name),
+            asset_url: upload.fetch(:asset_url),
+            comment_body: comment_body
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/organisms/demo_recorder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ace
+  module Demo
+    module Organisms
+      class DemoRecorder
+        SUPPORTED_FORMATS = %w[gif mp4 webm].freeze
+
+        def initialize(
+          resolver: Molecules::TapeResolver.new,
+          executor: Molecules::VhsExecutor.new,
+          yaml_parser: Atoms::DemoYamlParser,
+          yaml_compiler: Atoms::VhsTapeCompiler,
+          sandbox_builder: Molecules::DemoSandboxBuilder.new,
+          teardown_executor: Molecules::DemoTeardownExecutor.new,
+          output_dir: Demo.config["output_dir"],
+          vhs_bin: Demo.config["vhs_bin"]
+        )
+          @resolver = resolver
+          @executor = executor
+          @yaml_parser = yaml_parser
+          @yaml_compiler = yaml_compiler
+          @sandbox_builder = sandbox_builder
+          @teardown_executor = teardown_executor
+          @output_dir = output_dir || ".ace-local/demo"
+          @vhs_bin = vhs_bin || "vhs"
+        end
+
+        def record(tape_ref:, output: nil, format: nil)
+          normalized_format = format&.to_s&.downcase
+          if normalized_format && !SUPPORTED_FORMATS.include?(normalized_format)
+            raise ArgumentError, "Unsupported format: #{normalized_format}"
+          end
+
+          tape_path = @resolver.resolve(tape_ref)
+          return record_yaml_tape(tape_path: tape_path, output: output, format: normalized_format) if yaml_tape?(tape_path)
+
+          record_tape_file(tape_path: tape_path, output: output, format: normalized_format || "gif")
+        end
+
+        private
+
+        def record_tape_file(tape_path:, output:, format:)
+          output_path = File.expand_path(output || default_output_path(tape_path, format), Dir.pwd)
+          FileUtils.mkdir_p(File.dirname(output_path))
+
+          cmd = Atoms::VhsCommandBuilder.build(tape_path: tape_path, output_path: output_path, vhs_bin: @vhs_bin)
+          @executor.run(cmd)
+          output_path
+        end
+
+        def record_yaml_tape(tape_path:, output:, format:)
+          spec = @yaml_parser.parse_file(tape_path)
+          selected_format = (format || spec.dig("settings", "format") || "gif").to_s.downcase
+          raise ArgumentError, "Unsupported format: #{selected_format}" unless SUPPORTED_FORMATS.include?(selected_format)
+
+          output_path = File.expand_path(output || default_output_path(tape_path, selected_format), Dir.pwd)
+          FileUtils.mkdir_p(File.dirname(output_path))
+
+          sandbox = @sandbox_builder.build(source_tape_path: tape_path, setup_steps: spec["setup"] || [])
+          begin
+            compiled_tape_path = File.join(
+              sandbox[:path],
+              "#{File.basename(tape_path).sub(/\.ya?ml\z/, "")}.compiled.tape"
+            )
+            tape_output = "./#{File.basename(output_path)}"
+            tape_content = @yaml_compiler.compile(spec: spec, output_path: tape_output)
+            File.write(compiled_tape_path, tape_content)
+
+            cmd = Atoms::VhsCommandBuilder.build(
+              tape_path: compiled_tape_path,
+              output_path: output_path,
+              vhs_bin: @vhs_bin
+            )
+            @executor.run(cmd, chdir: sandbox[:path])
+            output_path
+          ensure
+            @teardown_executor.execute(steps: spec["teardown"] || [], sandbox_path: sandbox[:path]) if sandbox
+          end
+        end
+
+        def default_output_path(tape_ref, format)
+          basename = File.basename(tape_ref).sub(/\.tape\.ya?ml\z/, "").sub(/\.tape\z/, "").sub(/\.ya?ml\z/, "")
+          File.expand_path(File.join(@output_dir, "#{basename}.#{format}"), Dir.pwd)
+        end
+
+        def yaml_tape?(path)
+          path.end_with?(".tape.yml", ".tape.yaml")
+        end
+      end
+    end
+  end
+end