appydave-tools 0.11.11 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4596ba8f5d43c23761a5375cb0329b89ca6b18bb32a03686fd3427d4a73086b
-  data.tar.gz: 2a185916599f6c9d2578345b08bbc5e845fd0642f9bebab8d70c1b94ea4cf0cf
+  metadata.gz: e50556323b419ef5468e5199cf148812e25ff5c6001db7d35dc7f4cd52d7bb50
+  data.tar.gz: 23015d1c15d2fcde38f973fed02add0b7f55d09be3acda11f06705a15fcd6fdf
 SHA512:
-  metadata.gz: 5f4a96ad81115e20d39615547a012d58a5c6925d6f0841d31f2f91265d0412e937610229fde478e65b529c5b8cef437eed2d22f1152c4e2ad42cfa5fb45c8983
-  data.tar.gz: ae08e2209f871885fd94ae69530b1760cdf879dec9ac185cefb467e10a6bf5873fcbd33fe648f8f6c14603abe5962b7f00a15d8e23a8105aeef83a44d7cbac29
+  metadata.gz: 9f097fe81dae81d638bfa6040b44f9da187c95892a903a2e2c9e91c493134fd18fe0541e0b77daa99bfc56fa84378a1527d6d43f0955d74fdc038f3e9c4271a4
+  data.tar.gz: bdbf1c0ec19ce47042e17a16b8af96110e0e9b037fd61336debb32a5d251d80e50ce2259d4130b9bc220e9d95404b70c34b9ae9340e8ec557a1a595e0614e388

data/.rubocop.yml

@@ -91,6 +91,7 @@ Metrics/ParameterLists:
   Exclude:
     - "**/spec/**/*"
     - "**/models/**/*"
+    - "lib/appydave/tools/subtitle_master/join.rb"
 Layout/EmptyLineBetweenDefs:
   Exclude:
     - "**/spec/**/*"

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.11.11](https://github.com/appydave/appydave-tools/compare/v0.11.10...v0.11.11) (2024-11-26)
+
+
+### Bug Fixes
+
+* update clean srt specs ([e0da656](https://github.com/appydave/appydave-tools/commit/e0da656a3bf04f094bc3726a588a59d99d3d24a8))
+
 ## [0.11.10](https://github.com/appydave/appydave-tools/compare/v0.11.9...v0.11.10) (2024-11-26)
 
 

data/bin/move_images.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# CHAT: https://chatgpt.com/c/67038d52-9928-8002-8063-5616f7fe7aef
+
+# !/usr/bin/env ruby
+
+require 'fileutils'
+require 'optparse'
+
+# Default base directory
+base_dir = '/Volumes/Expansion/Sync/tube-channels/video-projects'
+
+# Common subfolder names (for reference, not enforced)
+# Common subfolders: intro, outro, content, teaser, thumb
+
+# Parse command-line options
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} -f <folder> <section> <prefix>"
+
+  opts.on('-f FOLDER', '--folder FOLDER', 'Specify the subfolder under video-projects') do |folder|
+    options[:folder] = folder
+  end
+end.parse!
+
+# Ensure the folder option is provided
+unless options[:folder]
+  puts 'You must specify a folder using the -f option'
+  exit 1
+end
+
+# Set source and destination directories
+source_dir = File.expand_path('~/Sync/smart-downloads/download-images')
+dest_dir = File.join(base_dir, options[:folder], 'assets')
+
+# Get input parameters
+section = ARGV[0]
+prefix = ARGV[1]
+
+unless prefix && section
+  puts "Usage: #{$PROGRAM_NAME} -f <folder> <section> <prefix>"
+  exit 1
+end
+
+# Ensure the section subfolder exists
+section_dir = File.join(dest_dir, section)
+puts "Creating subfolder if it doesn't exist: #{section_dir}"
+FileUtils.mkdir_p(section_dir)
+
+puts "Source directory: #{source_dir}"
+
+# Find and move the images
+Dir.glob("#{source_dir}/*.jpg").each_with_index do |file, index|
+  puts "Processing #{file}, #{index}"
+  new_filename = "#{prefix}-#{section}-#{index + 1}.jpg"
+  puts "New filename: #{new_filename}"
+  destination = File.join(section_dir, new_filename)
+  puts "Destination: #{destination}"
+  FileUtils.mv(file, destination)
+  puts "Moved #{file} to #{destination}"
+end

data/bin/subtitle_master-old.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'appydave/tools'
+
+# Process command line arguments for SubtitleMaster operations
+class SubtitleMasterCLI
+  def initialize
+    @commands = {
+      'clean' => method(:clean_subtitles),
+      'correct' => method(:correct_subtitles),
+      'split' => method(:split_subtitles),
+      'highlight' => method(:highlight_subtitles),
+      'image_prompts' => method(:generate_image_prompts)
+    }
+  end
+
+  def run
+    command, *args = ARGV
+    if @commands.key?(command)
+      @commands[command].call(args)
+    else
+      puts "Unknown command: #{command}"
+      print_help
+    end
+  end
+
+  private
+
+  def clean_subtitles(args)
+    options = parse_options(args, 'clean')
+    cleaner = Appydave::Tools::SubtitleMaster::Clean.new(file_path: options[:file])
+    result = cleaner.clean
+    write_output(result, options[:output])
+  end
+
+  def correct_subtitles(args)
+    options = parse_options(args, 'correct')
+    corrector = Appydave::Tools::SubtitleMaster::Correct.new(options[:file])
+    result = corrector.correct
+    write_output(result, options[:output])
+  end
+
+  def split_subtitles(args)
+    options = parse_options(args, 'split', %i[words_per_group])
+    splitter = Appydave::Tools::SubtitleMaster::Split.new(options[:file], options[:words_per_group])
+    result = splitter.split
+    write_output(result, options[:output])
+  end
+
+  def highlight_subtitles(args)
+    options = parse_options(args, 'highlight')
+    highlighter = Appydave::Tools::SubtitleMaster::Highlight.new(options[:file])
+    result = highlighter.highlight
+    write_output(result, options[:output])
+  end
+
+  def generate_image_prompts(args)
+    options = parse_options(args, 'image_prompts')
+    image_prompter = Appydave::Tools::SubtitleMaster::ImagePrompts.new(options[:file])
+    result = image_prompter.generate_prompts
+    write_output(result, options[:output])
+  end
+
+  def parse_options(args, command, extra_options = [])
+    options = { file: nil, output: nil }
+    OptionParser.new do |opts|
+      opts.banner = "Usage: subtitle_master.rb #{command} [options]"
+
+      opts.on('-f', '--file FILE', 'SRT file to process') { |v| options[:file] = v }
+      opts.on('-o', '--output FILE', 'Output file') { |v| options[:output] = v }
+
+      extra_options.each do |opt|
+        case opt
+        when :words_per_group
+          opts.on('-w', '--words-per-group WORDS', 'Number of words per group for splitting') { |v| options[:words_per_group] = v.to_i }
+        end
+      end
+
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end.parse!(args)
+
+    unless options[:file] && options[:output]
+      puts 'Missing required options. Use -h for help.'
+      exit
+    end
+
+    options
+  end
+
+  def write_output(result, output_file)
+    File.write(output_file, result)
+    puts "Processed file written to #{output_file}"
+  end
+
+  def print_help
+    puts 'Usage: subtitle_master.rb [command] [options]'
+    puts 'Commands:'
+    puts '  clean          Clean and normalize SRT files'
+    puts '  correct        Correct common typos and mistranslations in SRT files'
+    puts '  split          Split subtitle groups based on word count'
+    puts '  highlight      Highlight power words in subtitles'
+    puts '  image_prompts  Generate image prompts from subtitle text'
+    puts "Run 'subtitle_master.rb [command] --help' for more information on a command."
+  end
+end
+
+SubtitleMasterCLI.new.run

data/bin/subtitle_master.rb

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require 'optparse'
+
 $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
 
 require 'appydave/tools'
@@ -10,15 +12,18 @@ class SubtitleMasterCLI
   def initialize
     @commands = {
       'clean' => method(:clean_subtitles),
-      'correct' => method(:correct_subtitles),
-      'split' => method(:split_subtitles),
-      'highlight' => method(:highlight_subtitles),
-      'image_prompts' => method(:generate_image_prompts)
+      'join' => method(:join_subtitles)
     }
   end
 
   def run
     command, *args = ARGV
+    if command.nil?
+      puts 'No command provided. Use -h for help.'
+      print_help
+      exit
+    end
+
     if @commands.key?(command)
       @commands[command].call(args)
     else
@@ -30,82 +35,116 @@ class SubtitleMasterCLI
   private
 
   def clean_subtitles(args)
-    options = parse_options(args, 'clean')
+    options = { file: nil, output: nil }
+
+    # Command-specific option parser
+    clean_parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: subtitle_master.rb clean [options]'
+
+      opts.on('-f', '--file FILE', 'SRT file to process') do |v|
+        options[:file] = v
+      end
+
+      opts.on('-o', '--output FILE', 'Output file') do |v|
+        options[:output] = v
+      end
+
+      opts.on('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end
+
+    begin
+      clean_parser.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts "Error: #{e.message}"
+      puts clean_parser
+      exit
+    end
+
+    # Validate required options
+    if options[:file].nil? || options[:output].nil?
+      puts 'Error: Missing required options.'
+      puts clean_parser
+      exit
+    end
+
+    # Assuming `Appydave::Tools::SubtitleMaster::Clean` exists
     cleaner = Appydave::Tools::SubtitleMaster::Clean.new(file_path: options[:file])
-    result = cleaner.clean
-    write_output(result, options[:output])
+    cleaner.clean
+    cleaner.write(options[:output])
   end
 
-  def correct_subtitles(args)
-    options = parse_options(args, 'correct')
-    corrector = Appydave::Tools::SubtitleMaster::Correct.new(options[:file])
-    result = corrector.correct
-    write_output(result, options[:output])
-  end
+  def join_subtitles(args)
+    options = {
+      folder: './',
+      files: '*.srt',
+      sort: 'inferred',
+      buffer: 100,
+      output: 'merged.srt',
+      verbose: false
+    }
 
-  def split_subtitles(args)
-    options = parse_options(args, 'split', %i[words_per_group])
-    splitter = Appydave::Tools::SubtitleMaster::Split.new(options[:file], options[:words_per_group])
-    result = splitter.split
-    write_output(result, options[:output])
-  end
+    join_parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: subtitle_master.rb join [options]'
 
-  def highlight_subtitles(args)
-    options = parse_options(args, 'highlight')
-    highlighter = Appydave::Tools::SubtitleMaster::Highlight.new(options[:file])
-    result = highlighter.highlight
-    write_output(result, options[:output])
-  end
+      opts.on('-d', '--directory DIR', 'Directory containing SRT files (default: current directory)') do |v|
+        options[:folder] = v
+      end
 
-  def generate_image_prompts(args)
-    options = parse_options(args, 'image_prompts')
-    image_prompter = Appydave::Tools::SubtitleMaster::ImagePrompts.new(options[:file])
-    result = image_prompter.generate_prompts
-    write_output(result, options[:output])
-  end
+      opts.on('-f', '--files PATTERN', 'File pattern (e.g., "*.srt" or "part1.srt,part2.srt")') do |v|
+        options[:files] = v
+      end
 
-  def parse_options(args, command, extra_options = [])
-    options = { file: nil, output: nil }
-    OptionParser.new do |opts|
-      opts.banner = "Usage: subtitle_master.rb #{command} [options]"
+      opts.on('-s', '--sort ORDER', %w[asc desc inferred], 'Sort order (asc/desc/inferred)') do |v|
+        options[:sort] = v
+      end
 
-      opts.on('-f', '--file FILE', 'SRT file to process') { |v| options[:file] = v }
-      opts.on('-o', '--output FILE', 'Output file') { |v| options[:output] = v }
+      opts.on('-b', '--buffer MS', Integer, 'Buffer between merged files in milliseconds') do |v|
+        options[:buffer] = v
+      end
+
+      opts.on('-o', '--output FILE', 'Output file') do |v|
+        options[:output] = v
+      end
 
-      extra_options.each do |opt|
-        case opt
-        when :words_per_group
-          opts.on('-w', '--words-per-group WORDS', 'Number of words per group for splitting') { |v| options[:words_per_group] = v.to_i }
-        end
+      opts.on('-L', '--log-level LEVEL', %w[none info detail], 'Log level (default: info)') do |v|
+        options[:log_level] = v.to_sym
       end
 
-      opts.on_tail('-h', '--help', 'Show this message') do
+      opts.on('-h', '--help', 'Show this message') do
         puts opts
         exit
       end
-    end.parse!(args)
+    end
 
-    unless options[:file] && options[:output]
-      puts 'Missing required options. Use -h for help.'
+    begin
+      join_parser.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts "Error: #{e.message}"
+      puts join_parser
       exit
     end
 
-    options
-  end
+    # Validate required options
+    if options[:folder].nil? || options[:files].nil? || options[:output].nil?
+      puts 'Error: Missing required options.'
+      puts join_parser
+      exit
+    end
 
-  def write_output(result, output_file)
-    File.write(output_file, result)
-    puts "Processed file written to #{output_file}"
+    # Assuming `Appydave::Tools::SubtitleMaster::Join` exists
+    joiner = Appydave::Tools::SubtitleMaster::Join.new(folder: options[:folder], files: options[:files], sort: options[:sort], buffer: options[:buffer], output: options[:output],
+                                                       log_level: options[:log_level])
+    joiner.join
   end
 
   def print_help
     puts 'Usage: subtitle_master.rb [command] [options]'
     puts 'Commands:'
     puts '  clean          Clean and normalize SRT files'
-    puts '  correct        Correct common typos and mistranslations in SRT files'
-    puts '  split          Split subtitle groups based on word count'
-    puts '  highlight      Highlight power words in subtitles'
-    puts '  image_prompts  Generate image prompts from subtitle text'
+    puts '  join           Join multiple SRT files'
     puts "Run 'subtitle_master.rb [command] --help' for more information on a command."
   end
 end

data/lib/appydave/tools/subtitle_master/_doc-join.md

@@ -0,0 +1,166 @@
+
+# Detailed Requirements Specification
+
+## Command-Line Tool
+
+### Purpose
+A CLI tool named `Join` for merging multiple SRT files into one cohesive subtitle file, handling timestamp adjustment and preserving subtitle integrity.
+
+---
+
+### Parameters
+
+1. **`--folder <path>`**
+   - **Purpose**: Specifies the folder containing SRT files.  
+   - **Default**: Current working directory (`./`).  
+   - **Example**: `--folder /path/to/subtitles`.
+
+2. **`--files <pattern>`**
+   - **Purpose**: Specifies specific filenames or wildcard patterns for SRT files to process.  
+   - **Default**: `*.srt` (processes all SRT files in the folder).  
+   - **Logic**:  
+     - Explicit filenames: `file1.srt file2.srt` → Process in provided order.  
+     - Wildcard patterns: `*.srt` → Resolve matching files, sort by `--sort` order.
+
+3. **`--sort <inferred|asc|desc>`**
+   - **Purpose**: Defines how files are ordered for processing.  
+   - **Default**: `inferred`  
+   - **Logic**:  
+     - `inferred`:  
+       - Explicit filenames → Preserve order.  
+       - Wildcards → Sort alphabetically (ascending).  
+     - `asc`: Force alphabetical order.  
+     - `desc`: Force reverse alphabetical order.
+
+4. **`--buffer <milliseconds>`**
+   - **Purpose**: Adds a buffer between the last subtitle of one file and the first subtitle of the next.  
+   - **Default**: `100` (100ms).  
+   - **Example**: `--buffer 50` for a 50ms gap.
+
+5. **`--output <output_file.srt>`**
+   - **Purpose**: Specifies the name of the output merged SRT file.  
+   - **Default**: `merged.srt` in the current folder.  
+   - **Example**: `--output /path/to/final_output.srt`.
+
+6. **`--verbose`**
+   - **Purpose**: Enables detailed logging for steps like file resolution, timestamp adjustments, and warnings for skipped files.
+
+---
+
+## Primary Component Logic
+
+### Design Overview
+The tool should adhere to **Single Responsibility Principle (SRP)**, favor **composition**, and nest the composed components within the `Join` class for encapsulation and reusability.
+
+### Primary Class: `Join`
+The `Join` class acts as the main entry point and coordinates the workflow. It contains the following nested components:
+
+1. **`FileResolver`**
+   - **Responsibility**: Handles file resolution (folder, filenames, wildcards, sorting).
+   - **Logic**:  
+     - Resolve files based on `--files` or `--folder`.  
+     - Apply sorting rules (`inferred`, `asc`, `desc`).  
+
+2. **`SRTParser`**
+   - **Responsibility**: Parses SRT files into structured subtitle objects.
+   - **Logic**:  
+     - Read and validate SRT content.  
+     - Split into subtitle blocks (index, start time, end time, text).  
+     - Convert timestamps into structured objects (seconds for calculations).  
+
+3. **`SRTMerger`**
+   - **Responsibility**: Combines subtitles, adjusts timestamps, and applies buffers.
+   - **Logic**:  
+     - Aggregate parsed subtitles from multiple files.  
+     - Adjust timestamps for non-overlapping entries using the buffer.  
+
+4. **`SRTWriter`**
+   - **Responsibility**: Converts subtitle objects back to SRT format and writes to disk.
+   - **Logic**:  
+     - Reformat subtitles with proper numbering and timestamp formatting.  
+     - Write the final merged content to the specified output file.
+
+---
+
+### Main Workflow
+
+1. **Parse Arguments**
+   - Validate input parameters and resolve defaults.
+
+2. **Resolve Files**
+   - Use `FileResolver` to identify files based on folder, filenames, or wildcard patterns.
+
+3. **Parse Files**
+   - Use `SRTParser` to parse each file into a list of structured subtitle objects.
+
+4. **Merge Files**
+   - Use `SRTMerger` to combine subtitles, sort by start time (per file order), and apply timestamp adjustments.
+
+5. **Write Output**
+   - Use `SRTWriter` to generate the final SRT file and save it to the specified location.
+
+---
+
+## Business Rules
+
+1. **File Selection**
+   - Resolve wildcards to file lists dynamically.  
+   - Validate file existence and skip invalid or non-SRT files with appropriate warnings.
+
+2. **Timestamp Handling**
+   - Ensure non-overlapping subtitles across files by applying the buffer.  
+   - Maintain relative timing within each file.
+
+3. **Sorting Logic**
+   - Preserve file order for explicit filenames.  
+   - Apply alphabetical sorting for wildcards unless overridden by `--sort`.
+
+4. **Error Handling**
+   - Log and skip malformed SRT files.  
+   - Notify users of missing files or unsupported patterns.
+
+5. **Output Consistency**
+   - Re-number subtitles sequentially in the final output.  
+   - Ensure proper formatting with three decimal places for milliseconds.
+
+---
+
+## Tests
+
+### Unit Tests
+
+1. **FileResolver Tests**
+   - Resolve explicit filenames.
+   - Resolve wildcard patterns (`*.srt`) and sort files.
+   - Handle missing or invalid files gracefully.
+
+2. **SRTParser Tests**
+   - Parse valid SRT files into structured objects.
+   - Detect and handle malformed SRT files.
+   - Validate timestamp formatting.
+
+3. **SRTMerger Tests**
+   - Combine subtitles from two or more files.
+   - Ensure timestamps are adjusted with the buffer.
+   - Handle edge cases like overlapping timestamps or missing buffer.
+
+4. **SRTWriter Tests**
+   - Convert subtitle objects to valid SRT format.
+   - Ensure proper numbering and formatting (e.g., three decimal places).
+
+---
+
+### Integration Tests
+
+1. Process a folder of SRT files and produce a merged output.  
+2. Validate behavior with explicit filenames and wildcards.  
+3. Verify handling of buffers for different values (`0ms`, `50ms`, etc.).  
+4. Test edge cases like empty files, malformed SRTs, or mixed valid/invalid files.
+
+---
+
+### End-to-End Tests
+
+1. Run the tool with minimal arguments and verify the output.  
+2. Test all parameter combinations (`--folder`, `--files`, `--sort`, `--buffer`, etc.).  
+3. Compare merged output against manually validated reference files.

data/lib/appydave/tools/subtitle_master/clean.rb

@@ -5,6 +5,8 @@ module Appydave
     module SubtitleMaster
       # Clean and normalize subtitles
       class Clean
+        attr_reader :content
+
         def initialize(file_path: nil, srt_content: nil)
           if file_path && srt_content
             raise ArgumentError, 'You cannot provide both a file path and an SRT content stream.'
@@ -24,6 +26,15 @@ module Appydave
           normalize_lines(content)
         end
 
+        def write(output_file)
+          File.write(output_file, content)
+          puts "Processed file written to #{output_file}"
+        rescue Errno::EACCES
+          puts "Permission denied: Unable to write to #{output_file}"
+        rescue StandardError => e
+          puts "An error occurred while writing to the file: #{e.message}"
+        end
+
         private
 
         def remove_underscores(content)

data/lib/appydave/tools/subtitle_master/join.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module SubtitleMaster
+      # Join multiple SRT files into one
+      # - Supports folder, wildcards, sorting via FileResolver
+      class Join
+        # Handles file resolution (folder, wildcards, sorting)
+        class FileResolver
+          def initialize(folder:, files:, sort:)
+            raise ArgumentError, 'folder is required' if folder.nil?
+            raise ArgumentError, 'files is required' if files.nil?
+
+            @folder = folder
+            @files = files
+            @sort = sort
+          end
+
+          def process
+            # Check if folder exists before processing
+            raise Errno::ENOENT, "No such directory - #{@folder}" unless Dir.exist?(@folder)
+
+            file_patterns = @files.split(',').map(&:strip)
+            resolved_files = file_patterns.flat_map { |pattern| resolve_pattern(pattern) }
+            sort_files(resolved_files)
+          end
+
+          private
+
+          def resolve_pattern(pattern)
+            if pattern.include?('*')
+              Dir.glob(File.join(@folder, pattern))
+            else
+              file_path = File.join(@folder, pattern)
+              File.exist?(file_path) ? [file_path] : []
+            end
+          end
+
+          def sort_files(files)
+            case @sort
+            when 'asc'
+              files.sort
+            when 'desc'
+              files.sort.reverse
+            else # 'inferred'
+              # If explicit files were provided (no wildcards), maintain order
+              return files unless @files.include?('*')
+
+              files.sort
+            end
+          end
+        end
+
+        # Parses SRT files into structured subtitle objects
+        class SRTParser
+          # Represents a single subtitle entry
+          class Subtitle
+            attr_reader :index, :start_time, :end_time, :text
+
+            def initialize(index:, start_time:, end_time:, text:)
+              @index = index
+              @start_time = parse_timestamp(start_time)
+              @end_time = parse_timestamp(end_time)
+              @text = text.strip
+            end
+
+            private
+
+            # Converts SRT timestamp (00:00:00,000) to seconds (float)
+            def parse_timestamp(timestamp)
+              hours, minutes, seconds_ms = timestamp.split(':')
+              seconds, milliseconds = seconds_ms.split(',')
+
+              (hours.to_i * 3600) +
+                (minutes.to_i * 60) +
+                seconds.to_i +
+                (milliseconds.to_i / 1000.0)
+            end
+          end
+
+          def parse(content)
+            validate_content!(content)
+
+            subtitles = []
+            current_block = { text: [] }
+
+            content.split("\n").each do |line|
+              line = line.strip
+
+              if line.empty?
+                process_block(current_block, subtitles) if current_block[:index]
+                current_block = { text: [] }
+                next
+              end
+
+              if current_block[:index].nil?
+                current_block[:index] = line.to_i
+              elsif current_block[:timestamp].nil? && line.include?(' --> ')
+                start_time, end_time = line.split(' --> ')
+                current_block[:timestamp] = { start: start_time, end: end_time }
+              else
+                current_block[:text] << line
+              end
+            end
+
+            # Process the last block if it exists
+            process_block(current_block, subtitles) if current_block[:index]
+
+            subtitles
+          end
+
+          private
+
+          def validate_content!(content)
+            raise ArgumentError, 'Content cannot be nil' if content.nil?
+            raise ArgumentError, 'Content cannot be empty' if content.strip.empty?
+
+            # Basic structure validation - should have numbers and timestamps
+            return if content.match?(/\d+\s*\n\d{2}:\d{2}:\d{2},\d{3}\s*-->\s*\d{2}:\d{2}:\d{2},\d{3}/)
+
+            raise ArgumentError, 'Invalid SRT format: missing required timestamp format'
+          end
+
+          def process_block(block, subtitles)
+            return unless block[:index] && block[:timestamp] && !block[:text].empty?
+
+            subtitles << Subtitle.new(
+              index: block[:index],
+              start_time: block[:timestamp][:start],
+              end_time: block[:timestamp][:end],
+              text: block[:text].join("\n")
+            )
+          end
+        end
+
+        # Merges multiple subtitle arrays while maintaining timing and adding buffers
+        class SRTMerger
+          def initialize(buffer_ms: 100)
+            @buffer_ms = buffer_ms.to_f
+          end
+
+          def merge(subtitle_arrays)
+            return [] if subtitle_arrays.empty?
+
+            merged = []
+            current_end_time = 0.0
+
+            subtitle_arrays.each do |subtitles|
+              next if subtitles.empty?
+
+              # Calculate offset needed for this batch of subtitles
+              first_subtitle = subtitles.first
+              offset_seconds = calculate_offset(current_end_time, first_subtitle.start_time)
+
+              # Add adjusted subtitles to merged array
+              subtitles.each do |subtitle|
+                adjusted_subtitle = adjust_subtitle_timing(subtitle, offset_seconds)
+                merged << adjusted_subtitle
+              end
+
+              # Update current_end_time for next batch
+              current_end_time = merged.last.end_time
+            end
+
+            # Renumber subtitles sequentially
+            merged.each_with_index do |subtitle, index|
+              subtitle.instance_variable_set(:@index, index + 1)
+            end
+
+            merged
+          end
+
+          private
+
+          def calculate_offset(current_end_time, next_start_time)
+            return 0.0 if current_end_time.zero?
+
+            buffer_seconds = @buffer_ms / 1000.0
+            needed_offset = current_end_time + buffer_seconds - next_start_time
+            [needed_offset, 0].max
+          end
+
+          def adjust_subtitle_timing(subtitle, offset_seconds)
+            # Create new Subtitle instance with adjusted timing
+            SRTParser::Subtitle.new(
+              index: subtitle.index,
+              start_time: format_time(subtitle.start_time + offset_seconds),
+              end_time: format_time(subtitle.end_time + offset_seconds),
+              text: subtitle.text
+            )
+          end
+
+          def format_time(seconds)
+            # Convert seconds back to SRT timestamp format (00:00:00,000)
+            hours = (seconds / 3600).floor
+            minutes = ((seconds % 3600) / 60).floor
+            seconds_remaining = seconds % 60
+            milliseconds = ((seconds_remaining % 1) * 1000).round
+
+            format(
+              '%<hours>02d:%<minutes>02d:%<seconds>02d,%<milliseconds>03d',
+              hours: hours,
+              minutes: minutes,
+              seconds: seconds_remaining.floor,
+              milliseconds: milliseconds
+            )
+          end
+        end
+
+        # Converts subtitle objects back to SRT format and writes to disk
+        class SRTWriter
+          def initialize(output_file)
+            @output_file = output_file
+          end
+
+          def write(subtitles)
+            content = format_subtitles(subtitles)
+            File.write(@output_file, content, encoding: 'UTF-8')
+          end
+
+          private
+
+          def format_subtitles(subtitles)
+            subtitles.each_with_index.map do |subtitle, index|
+              [
+                index + 1, # Force sequential numbering
+                format_timestamp_line(subtitle),
+                subtitle.text,
+                '' # Empty line between subtitle blocks
+              ].join("\n")
+            end.join("\n")
+          end
+
+          def format_timestamp_line(subtitle)
+            "#{format_timestamp(subtitle.start_time)} --> #{format_timestamp(subtitle.end_time)}"
+          end
+
+          def format_timestamp(seconds)
+            hours = (seconds / 3600).floor
+            minutes = ((seconds % 3600) / 60).floor
+            seconds_remaining = seconds % 60
+            milliseconds = ((seconds_remaining % 1) * 1000).round
+
+            format(
+              '%<hours>02d:%<minutes>02d:%<seconds>02d,%<milliseconds>03d',
+              hours: hours,
+              minutes: minutes,
+              seconds: seconds_remaining.floor,
+              milliseconds: milliseconds
+            )
+          end
+        end
+
+        # Simple logger for debugging
+        class Logger
+          LEVELS = { none: 0, info: 1, detail: 2 }.freeze
+
+          def initialize(level = :info)
+            @level = LEVELS[level] || LEVELS[:info]
+          end
+
+          def log(level, message)
+            puts message if LEVELS[level] <= @level
+          end
+        end
+
+        def initialize(folder: './', files: '*.srt', sort: 'inferred', buffer: 100, output: 'merged.srt', log_level: :info)
+          @folder = folder
+          @files = files
+          @sort = sort
+          @buffer = buffer
+          @output = output
+          @logger = Logger.new(log_level)
+        end
+
+        def join
+          @logger.log(:info, "Starting join operation in folder: #{@folder} with files: #{@files}")
+          resolved_files = resolve_files
+          @logger.log(:info, "Resolved files: #{resolved_files.join(', ')}")
+
+          subtitle_groups = parse_files(resolved_files)
+          @logger.log(:detail, "Parsed subtitles: #{subtitle_groups.map(&:size)} from files.")
+
+          merged_subtitles = merge_subtitles(subtitle_groups)
+          @logger.log(:info, "Merged #{subtitle_groups.flatten.size} subtitles into #{merged_subtitles.size} blocks.")
+
+          write_output(merged_subtitles)
+          @logger.log(:info, "Output written to #{@output}")
+        end
+
+        private
+
+        def resolve_files
+          resolver = FileResolver.new(
+            folder: @folder,
+            files: @files,
+            sort: @sort
+          )
+          resolver.process
+        end
+
+        def parse_files(files)
+          files.map do |file|
+            content = File.read(file, encoding: 'UTF-8')
+            parse_srt_content(content)
+          end
+        end
+
+        def parse_srt_content(content)
+          parser = SRTParser.new
+          parser.parse(content)
+        end
+
+        def merge_subtitles(subtitle_groups)
+          merger = SRTMerger.new(buffer_ms: @buffer)
+          merger.merge(subtitle_groups)
+        end
+
+        def write_output(subtitles)
+          writer = SRTWriter.new(@output)
+          writer.write(subtitles)
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Appydave
   module Tools
-    VERSION = '0.11.11'
+    VERSION = '0.12.0'
   end
 end

data/lib/appydave/tools.rb

@@ -44,18 +44,14 @@ require 'appydave/tools/configuration/configurable'
 require 'appydave/tools/configuration/config'
 require 'appydave/tools/configuration/models/config_base'
 require 'appydave/tools/configuration/models/settings_config'
-# require 'appydave/tools/configuration/models/bank_reconciliation_config'
 require 'appydave/tools/configuration/models/channels_config'
 require 'appydave/tools/configuration/models/youtube_automation_config'
 require 'appydave/tools/name_manager/project_name'
-# require 'appydave/tools/bank_reconciliation/clean/clean_transactions'
-# require 'appydave/tools/bank_reconciliation/clean/read_transactions'
-# require 'appydave/tools/bank_reconciliation/clean/mapper'
-# require 'appydave/tools/bank_reconciliation/models/transaction'
 
 require 'appydave/tools/prompt_tools/prompt_completion'
 
 require 'appydave/tools/subtitle_master/clean'
+require 'appydave/tools/subtitle_master/join'
 
 require 'appydave/tools/youtube_automation/gpt_agent'
 

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "appydave-tools",
-  "version": "0.11.11",
+  "version": "0.12.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "appydave-tools",
-      "version": "0.11.11",
+      "version": "0.12.0",
       "devDependencies": {
         "@klueless-js/semantic-release-rubygem": "github:klueless-js/semantic-release-rubygem",
         "@semantic-release/changelog": "^6.0.3",

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appydave-tools",
-  "version": "0.11.11",
+  "version": "0.12.0",
   "description": "AppyDave YouTube Automation Tools",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appydave-tools
 version: !ruby/object:Gem::Version
-  version: 0.11.11
+  version: 0.12.0
 platform: ruby
 authors:
 - David Cruwys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-26 00:00:00.000000000 Z
+date: 2024-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -160,8 +160,10 @@ files:
 - bin/configuration.rb
 - bin/console
 - bin/gpt_context.rb
+- bin/move_images.rb
 - bin/prompt_tools.rb
 - bin/setup
+- bin/subtitle_master-old.rb
 - bin/subtitle_master.rb
 - bin/youtube_automation.rb
 - bin/youtube_manager.rb
@@ -193,9 +195,11 @@ files:
 - lib/appydave/tools/name_manager/project_name.rb
 - lib/appydave/tools/prompt_tools/_doc.md
 - lib/appydave/tools/prompt_tools/prompt_completion.rb
+- lib/appydave/tools/subtitle_master/_doc-clean.md
+- lib/appydave/tools/subtitle_master/_doc-join.md
 - lib/appydave/tools/subtitle_master/_doc-todo.md
-- lib/appydave/tools/subtitle_master/_doc.md
 - lib/appydave/tools/subtitle_master/clean.rb
+- lib/appydave/tools/subtitle_master/join.rb
 - lib/appydave/tools/types/array_type.rb
 - lib/appydave/tools/types/base_model.rb
 - lib/appydave/tools/types/hash_type.rb