CatFlac 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4d1e4c8b93c0743c857ee7ffefc5881567bab443b6e714849875c9ae436002df
+  data.tar.gz: f3e6af35d05b0ce0389e26875ac3ce984c6312a828405713e1a66c64ce33866a
+SHA512:
+  metadata.gz: e8acfc5517a0af8d90850d9b756bc2f14118e987b06c7ad90f49e97bc97eb5128c356e9a8dfdfa9ae1d611cd8109656a758b745ffb1259abebdfffe760da44e9
+  data.tar.gz: 2af852e5b8d2fb962c6257ad50f1f5514c35a7758a25355ce28dd3d7edcf17d02519c7ef5419240ec1b7a75df4fbae20737517fecf16da2fefe19ff3ccd465c1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-02-05
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alex Acht
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# 🧶 CatFlac
+
+<p align="center">
+<img src="assets/mascot.png" alt="CatFlac Mascot" width="200">
+</p>
+
+
+>
+> CatFlac is a simple tool for splitting large audio files. It's currently in its initial stage - functional, but probably needs some improvements.
+
+---
+
+##   Current Skills
+
+*    **CUE Support**: Handles basic external and embedded CUE sheets.
+*    **Experimental AI**: A curious attempt at track identification (requires `AI_API_KEY`).
+
+
+---
+
+## 🐾 Getting Started
+
+First of all you need to install ffmpeg on your system.
+
+```bash
+sudo apt install ffmpeg
+```
+
+Then install the gem:
+
+```bash
+gem install CatFlac
+```
+
+Or add this to your application's `Gemfile`:
+
+```ruby
+gem 'CatFlac'
+```
+
+And then run:
+```bash
+bundle install
+```
+
+##   Usage
+
+Using CatFlac is pretty straightforward.
+
+### Command Line Interface
+
+Just point CatFlac to a folder containing your audio files:
+
+```bash
+CatFlac split /path/to/your/music_folder
+```
+
+### Ruby API
+
+Integrating CatFlac into your project:
+
+```ruby
+require 'CatFlac'
+
+CatFlac.cat!('/path/to/your/music_folder')
+```
+
+### Experimental AI Mode
+
+If you don't have a CUE sheet, you can try letting CatFlac guess the tracks. To do so, set perplexity api key as an environment variable:
+
+```bash
+export AI_API_KEY='api_key_here'
+
+CatFlac split /path/to/mysterious_album
+```
+
+##  Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/lxndr128/CatFlac](https://github.com/lxndr128/CatFlac)
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](LICENSE.txt).
+
+---
+
+

data/exe/catflac

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "cat_flac"
+require "thor"
+class CatFlacCLI < Thor
+  def self.exit_on_failure?
+    true
+  end
+  desc "cat FILE_PATH", "Split a FLAC file on tracks"
+  def cat(file_path)
+    CatFlac.cat!(file_path)
+  end
+
+  desc "cut FILE_PATH", "Split a FLAC file on tracks"
+  alias_method :cut, :cat
+
+  desc "split FILE_PATH", "Split a FLAC file on tracks"
+  alias_method :split, :cat
+end
+
+CatFlacCLI.start(ARGV)

data/lib/CatFlac/album.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CatFlac
+  class Album
+    attr_reader :title, :artist, :year, :source_file, :tracks, :release_date, :cover
+
+    def initialize(title:, artist:, cover:, release_date:, genre:, source_file: nil, tracks: [])
+      @title = title
+      @artist = artist
+      @source_file = source_file
+      @tracks = tracks
+      @cover = cover
+      @genre = genre
+      @release_date = release_date
+    end
+
+    def add_track(track)
+      @tracks << track
+    end
+  end
+end

data/lib/CatFlac/parsers/_base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CatFlac
+  module Parsers
+    class Base
+      AUDIO_EXTENSIONS = %w[
+        flac wav ape wv m4a mp3 ogg opus tta tak aiff aif m4b
+      ].freeze
+
+      COVER_EXTENTIONS = %w[
+        img jpg png jpeg
+      ].freeze
+
+      attr_reader :path
+
+      def self.parse(target_folder_path:)
+        @path = target_folder_path
+        select_parser.new(target_folder_path).parse
+      rescue ParserError
+        raise
+      rescue StandardError => e
+        raise ParserError, "Unexpected error during parsing: #{e.message}"
+      end
+
+      def self.select_parser
+        parsers = subclasses.sort_by { |klass| klass::ORDER }
+        parsers.each do |parser_class|
+          return parser_class if parser_class.match?(@path)
+        end
+
+        raise NoMatchingParserError, "No suitable parser found for path: #{@path}"
+      end
+
+      def self.match?
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/_helpers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CatFlac
+  module Parsers
+    module Helpers
+      module_function
+
+      def read_cue_content(cue_path)
+        File.read(cue_path, encoding: "UTF-8")
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        File.read(cue_path, encoding: "Windows-1251").encode("UTF-8")
+      end
+
+      def get_audio_duration(path)
+        require "streamio-ffmpeg"
+        duration = FFMPEG::Movie.new(path).duration
+        Time.at(duration).utc.strftime("%M:%S:%L")
+      rescue StandardError => e
+        raise CatFlac::Error, "Failed to analyze audio file: #{e.message}"
+      end
+
+      def time_to_seconds(time)
+        time_str = time.to_s
+        return if time_str.empty?
+
+        minutes, seconds, frames = time_str.split(":").map(&:to_i)
+
+        (minutes * 60) + seconds + (frames / 75.0)
+      end
+
+      def find_cover(extensions, path)
+        imgs = Dir.glob(File.join(path, "*.{#{extensions.join(',')}}"))
+        return unless imgs.one?
+
+        imgs.first
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/ai/request.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+
+module CatFlac
+  module Parsers
+    module AI
+      module Request
+        PROMPT = <<-TEXT
+          You are a music metadata expert. Use MusicBrainz or Discogs, and ONLY in case you can't find
+          anything there use another sources.
+
+          1. Identify the album or albums from these files
+          2. Find the EXACT official tracklist with durations (MM:SS:FF format)
+          3. Match files to tracks by order and duration
+          4. Return accurate data from the database, not the files
+          5. USE PROVIDED SCHEMA! STRICTLY. THERE IS COMPLETED DESCRIPTION OF DATA WHAT WE NEED IN THIS SCHEMA
+          6. Check output json on syntax errors.
+          7. Be carefull, some releases could be described as one big track, but still contain a few different tracks inside.
+             We want to split it anyway, don't care about artistic obstacles
+
+        TEXT
+
+        RESPONSE_SCHEMA = {
+          albums: [
+            {
+              source_file: { type: "string", description: "Relative path to the music file" },
+              title: { type: "string" },
+              artist: { type: "string" },
+              cover: { type: "string", description: "Relative path to the cover file" },
+              genre: { type: "string" },
+              release_date: { type: "string" },
+              tracks: [
+                {
+                  cover: { type: %w[string null], description: "Only in case of separate covers for each track" },
+                  number: { type: "string" },
+                  title: { type: "string" },
+                  artist: { type: "string" },
+                  duration: { type: "string (CUE format 75 frames)", format: "mm:ss:ff" }
+                }
+              ]
+            }
+          ]
+        }.freeze
+
+        module_function
+
+        def make_request(files, formats)
+          return JSON.parse(File.read("mock.json")) if File.exist?("mock.json")
+
+          uri = URI("https://api.perplexity.ai/v1/responses")
+
+          request = Net::HTTP::Post.new(uri)
+          request["Authorization"] = "Bearer #{ENV.fetch('AI_API_KEY', nil)}"
+          request["Content-Type"] = "application/json"
+
+          request.body = body(files, formats).to_json
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: 300) do |https|
+            https.request(request)
+          end
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise APIError, "AI API request failed: #{response.code} #{response.message}"
+          end
+
+          text = JSON.parse(response.body).dig("output", -1, "content", -1, "text")
+          JSON.parse(text)["albums"]
+        rescue JSON::ParserError => e
+          raise ParserError, "Failed to parse AI response: #{e.message}"
+        rescue Net::HTTPError, SocketError, Timeout::Error => e
+          raise APIError, "Network error during AI request: #{e.message}"
+        end
+
+        def body(files, formats)
+          content = "#{PROMPT}\nFILES:\n#{files}\nMETADATA:\n#{formats}Respone shema#{RESPONSE_SCHEMA.to_json}"
+          {
+            input: [
+              {
+                type: "message",
+                role: "system",
+                content: content
+              }
+            ],
+            instructions: "Use web_search to find exact metadata from MusicBrainz/Discogs. Never guess.",
+            model: "perplexity/sonar",
+            tools: [
+              {
+                type: "web_search",
+                filters: {
+                  search_domain_filter: ["musicbrainz.org", "discogs.com", "youtube.com"]
+                }
+              }
+            ]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/ai_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CatFlac
+  module Parsers
+    class AIParser < Base
+      ORDER = 3
+
+      def self.match?(path)
+        return false unless ENV["AI_API_KEY"]
+
+        Dir.glob(File.join(path, "*.{#{AUDIO_EXTENSIONS.join(',')}}")).any?
+      end
+
+      def initialize(path)
+        formats = Dir.glob(File.join(path, "**/*.{#{AUDIO_EXTENSIONS.join(',')}}")).map do |path_|
+          `ffprobe -v quiet -print_format json -show_format "#{path_}"`
+        end.join("\n")
+
+        files = Dir.glob(File.join(path, "*")).join("\n")
+
+        @albums = AI::Request.make_request(files, formats)
+      end
+
+      def parse
+        @albums.map { |album| Builders::AiAlbumBuilder.make_album(album) }
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/builders/ai_album_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CatFlac
+  module Parsers
+    module Builders
+      module AiAlbumBuilder
+        module_function
+
+        def make_album(album_data)
+          album = CatFlac::Album.new(
+            title: album_data["title"],
+            artist: album_data["artist"],
+            source_file: album_data["source_file"],
+            genre: album_data["genre"],
+            cover: album_data["cover"],
+            release_date: album_data["release_date"]
+          )
+
+          start_time = 0
+
+          album_data["tracks"].each_with_index do |track_data, index|
+            duration = Helpers.time_to_seconds(track_data["duration"])
+
+            track = CatFlac::Track.new(
+              album: album_data["title"],
+              number: (track_data["number"] || (index + 1)).to_i,
+              title: track_data["title"],
+              artist: track_data["artist"],
+              start_time: start_time,
+              duration: duration,
+              genre: album_data["genre"]
+            )
+
+            start_time += duration
+
+            album.add_track(track)
+          end
+
+          album
+        end
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/builders/cue_album_builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CatFlac
+  module Parsers
+    module Builders
+      module CueAlbumBuilder
+        module_function
+
+        def make_album(cuesheet, audio_path, path)
+          album = CatFlac::Album.new(
+            title: cuesheet.title,
+            artist: cuesheet.performer,
+            source_file: audio_path,
+            genre: cuesheet.genre,
+            cover: Helpers.find_cover(Base::COVER_EXTENTIONS, path),
+            release_date: cuesheet.year
+          )
+
+          total_duration = Helpers.get_audio_duration(audio_path)
+
+          cuesheet.songs.each_with_index do |song_data, index|
+            start_time = Helpers.time_to_seconds(song_data[:index].to_s)
+            next_song = cuesheet.songs[index + 1]
+            end_time = Helpers.time_to_seconds(next_song&.[](:index) || total_duration)
+            duration = end_time - start_time
+            duration = 0 if duration.negative?
+
+            track = CatFlac::Track.new(
+              album: album,
+              number: (song_data[:track] || (index + 1)).to_i,
+              title: song_data[:title],
+              artist: song_data[:performer],
+              start_time: start_time,
+              duration: duration,
+              genre: cuesheet.genre
+            )
+
+            album.add_track(track)
+          end
+
+          album
+        end
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/chapters_parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CatFlac
+  module Parsers
+    # TODO
+    class ChaptersParser < Base
+      ORDER = 2
+      # `ffprobe -v quiet -print_format json -show_format -show_streams -show_chapters "#{@audio_path}"`
+      def self.match?(_path)
+        false
+      end
+
+      private
+
+      def extract_embedded_chapters(file)
+        cmd = `ffprobe -v quiet -print_format json -show_format -show_chapters \"#{file}\"`
+        JSON.parse(cmd)
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/cue_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../vendor/rubycue-master/lib/rubycue"
+
+module CatFlac
+  module Parsers
+    class CueParser < Base
+      ORDER = 0
+
+      def self.match?(path)
+        return false unless Dir.glob(File.join(path, "*.cue")).one?
+
+        Dir.glob(File.join(path, "*.{#{AUDIO_EXTENSIONS.join(',')}}")).one?
+      end
+
+      def initialize(path)
+        @path = path
+        cue_path = Dir.glob(File.join(path, "*.cue")).first
+        @audio_path = Dir.glob(File.join(path, "*.{#{AUDIO_EXTENSIONS.join(',')}}")).first
+        begin
+          @cuesheet = ::RubyCue::Cuesheet.new(Helpers.read_cue_content(cue_path)).tap(&:parse!)
+        rescue StandardError => e
+          raise ParserError, "Failed to parse cuesheet #{cue_path}: #{e.message}"
+        end
+      end
+
+      def parse
+        [Builders::CueAlbumBuilder.make_album(@cuesheet, @audio_path, @path)]
+      end
+    end
+  end
+end

data/lib/CatFlac/parsers/embedded_cue_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "English"
+module CatFlac
+  module Parsers
+    class EmbeddedCueParser < CueParser
+      ORDER = 1
+
+      def self.match?(path)
+        return false unless Dir.glob(File.join(path, "*.cue")).none?
+
+        files = Dir.glob(File.join(path, "*.{#{AUDIO_EXTENSIONS.join(',')}}"))
+        return false unless files.one?
+
+        extract_embedded_cuesheet(files.last).present?
+      end
+
+      def initialize(path)
+        @audio_path = Dir.glob(File.join(path, "*.{#{AUDIO_EXTENSIONS.join(',')}}")).first
+        cue = self.class.extract_embedded_cuesheet(@audio_path)
+        @cuesheet = ::RubyCue::Cuesheet.new(cue).tap(&:parse!)
+      end
+
+      def self.extract_embedded_cuesheet(file)
+        cmd = "ffprobe -v quiet -print_format json -show_format \"#{file}\""
+        output = `#{cmd}`
+
+        raise CommandError, "Failed to run ffprobe: #{$CHILD_STATUS.exitstatus}" unless $CHILD_STATUS.success?
+
+        tags = JSON.parse(output).dig("format", "tags") || {}
+        tags[tags.keys.find { |k| k.upcase == "CUESHEET" }]
+      rescue JSON::ParserError => e
+        raise ParserError, "Failed to parse ffprobe output: #{e.message}"
+      end
+    end
+  end
+end

data/lib/CatFlac/splitter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module CatFlac
+  class Splitter
+    def self.split(album)
+      FileUtils.mkdir_p(album.title)
+      ext = File.extname(album.source_file)
+
+      album.tracks.each do |track|
+        output_file = File.join(album.title, (track.filename + ext).to_s)
+
+        cmd = [
+          "ffmpeg",
+          "-y",
+          "-i", album.source_file
+        ]
+
+        cmd += ["-i", album.cover] if album.cover
+
+        cmd += [
+          "-ss", track.start_time.to_s,
+          "-t", track.duration.to_s
+        ]
+
+        if album.cover
+          cmd += ["-map", "0:a", "-map", "1:0"]
+          cmd += ["-c:v", "mjpeg"]
+          cmd += ["-disposition:v", "attached_pic"]
+        else
+          cmd += ["-map", "0:a"]
+        end
+
+        cmd += [
+          "-metadata", "title=#{track.title}",
+          "-metadata", "artist=#{track.artist}",
+          "-metadata", "track=#{track.number}",
+          "-metadata", "genre=#{track.genre}",
+          "-metadata", "album=#{album.title}"
+        ]
+
+        cmd << output_file
+
+        ok = system(*cmd)
+        raise CommandError, "ffmpeg failed for #{output_file}" unless ok
+      end
+    end
+  end
+end

data/lib/CatFlac/track.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CatFlac
+  class Track
+    attr_reader :album, :cover, :number, :title, :artist, :start_time, :duration, :genre
+
+    def initialize(album:, number:, title:, artist:, start_time: nil, duration: nil, genre: nil, cover: nil)
+      @album = album
+      @cover = cover
+      @number = number
+      @title = title
+      @artist = artist
+      @start_time = start_time
+      @duration = duration
+      @genre = genre
+    end
+
+    def filename
+      safe_title = title.gsub(%r{[/\\]}, "-")
+      "#{number.to_s.rjust(2, '0')}. #{artist} - #{safe_title}"
+    end
+  end
+end

data/lib/CatFlac/vendor/rubycue-master/LICENSE

@@ -0,0 +1,26 @@
+ author: Blake Smith
+ description: Basic ruby parser for song cuesheets
+ email: blakesmith0@gmail.com
+ homepage: http://github.com/blakesmith/rubycue
+
+Copyright (c) 2010 Blake Smith
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/lib/CatFlac/vendor/rubycue-master/lib/rubycue/cuesheet.rb

@@ -0,0 +1,120 @@
+module RubyCue
+  class Cuesheet
+    attr_reader :cuesheet, :songs, :track_duration, :performer, :title, :file, :genre, :year
+
+    def initialize(cuesheet, track_duration=nil)
+      @cuesheet = cuesheet      
+      @reg = {
+        :track => %r(TRACK (\d{1,3}) AUDIO),
+        :performer => %r(PERFORMER "(.*)"),
+        :title => %r(TITLE "(.*)"),
+        :index => %r(INDEX \d{1,3} (\d{1,3}):(\d{1,2}):(\d{1,2})),
+        :file => %r(FILE "(.*)"),
+        :genre => %r(REM GENRE (.*)\b),
+        :year => %r(YEAR "(.*)")
+      }
+      @track_duration = RubyCue::Index.new(track_duration) if track_duration
+    end
+
+    def parse!
+      @songs = parse_titles.map{|title| {:title => title}}
+      @songs.each_with_index do |song, i|
+        song[:performer] = parse_performers[i]
+        song[:track] = parse_tracks[i]
+        song[:index] = parse_indices[i]
+        song[:file] = parse_files[i]
+      end
+      parse_genre
+      parse_year
+      raise RubyCue::InvalidCuesheet.new("Field amounts are not all present. Cuesheet is malformed!") unless valid?
+      calculate_song_durations!
+      true
+    end
+
+    def position(value)
+      index = Index.new(value)
+      return @songs.first if index < @songs.first[:index]
+      @songs.each_with_index do |song, i|
+        return song if song == @songs.last
+        return song if between(song[:index], @songs[i+1][:index], index)
+      end
+    end
+
+    def valid?
+      @songs.all? do |song|
+        [:performer, :track, :index, :title].all? do |key|
+          song[key] != nil
+        end
+      end
+    end
+
+  private
+
+    def calculate_song_durations!
+      @songs.each_with_index do |song, i|
+        if song == @songs.last
+          song[:duration] = (@track_duration - song[:index]) if @track_duration
+          return
+        end
+        song[:duration] = @songs[i+1][:index] - song[:index]
+      end
+    end
+
+    def between(a, b, position_index)
+      (position_index > a) && (position_index < b)
+    end
+
+    def parse_titles
+      unless @titles
+        @titles = cuesheet_scan(:title).map{|title| title.first}
+        @title = @titles.delete_at(0)
+      end
+      @titles
+    end
+
+    def parse_performers
+      unless @performers
+        @performers = cuesheet_scan(:performer).map{|performer| performer.first}
+        @performer = @performers.delete_at(0)
+      end
+      @performers
+    end
+
+    def parse_tracks
+      @tracks ||= cuesheet_scan(:track).map{|track| track.first.to_i}
+    end
+
+    def parse_indices
+      @indices ||= cuesheet_scan(:index).map{|index| RubyCue::Index.new([index[0].to_i, index[1].to_i, index[2].to_i])}
+    end
+
+    def parse_files
+      unless @files
+        @files = cuesheet_scan(:file).map{|file| file.first}
+        @file = @files.delete_at(0) if @files.size == 1
+      end
+      @files
+    end
+
+    def parse_genre
+      @cuesheet.scan(@reg[:genre]) do |genre|
+        @genre = genre.first
+        break
+      end
+    end
+
+    def parse_year
+      @cuesheet.scan(@reg[:year]) do |year|
+        @year = year.first
+        break
+      end
+    end
+
+    def cuesheet_scan(field)
+      scan = @cuesheet.scan(@reg[field])
+      raise InvalidCuesheet.new("No fields were found for #{field.to_s}") if scan.empty?
+      scan
+    end
+
+  end
+end

data/lib/CatFlac/vendor/rubycue-master/lib/rubycue/exceptions.rb

@@ -0,0 +1,3 @@
+module RubyCue
+  class InvalidCuesheet < ::RuntimeError; end
+end

data/lib/CatFlac/vendor/rubycue-master/lib/rubycue/index.rb

@@ -0,0 +1,108 @@
+module RubyCue
+  class Index
+    SECONDS_PER_MINUTE = 60
+    FRAMES_PER_SECOND = 75
+    FRAMES_PER_MINUTE = FRAMES_PER_SECOND * 60
+
+    attr_reader :minutes, :seconds, :frames
+
+    def initialize(value=nil)
+      case value
+      when Array
+        set_from_array!(value)
+      when Integer
+        set_from_integer!(value)
+      end
+    end
+
+    def to_f
+      ((@minutes * SECONDS_PER_MINUTE) + (@seconds) + (@frames.to_f / FRAMES_PER_SECOND)).to_f
+    end
+
+    def to_i
+      to_f.floor
+    end
+
+    def to_a
+      [@minutes, @seconds, @frames]
+    end
+
+    def to_s
+      "#{'%02d' % @minutes}:#{'%02d' % @seconds}:#{'%02d' % @frames}"
+    end
+
+    def +(other)
+      self.class.new(carrying_addition(other))
+    end
+
+    def -(other)
+      self.class.new(carrying_subtraction(other))
+    end
+
+    def >(other)
+      self.to_f > other.to_f
+    end
+
+    def <(other)
+      self.to_f < other.to_f
+    end
+
+    def ==(other)
+      self.to_a == other.to_a
+    end
+
+    def each
+      to_a.each {|value| yield value }
+    end
+
+    private
+
+    def carrying_addition(other)
+      minutes, seconds, frames = *[@minutes + other.minutes, 
+        @seconds + other.seconds, @frames + other.frames]
+
+      seconds, frames = *convert_with_rate(frames, seconds, FRAMES_PER_SECOND)
+      minutes, seconds = *convert_with_rate(seconds, minutes, SECONDS_PER_MINUTE)
+      [minutes, seconds, frames]
+    end
+
+    def carrying_subtraction(other)
+      seconds = minutes = 0
+
+      my_frames = @frames + (@seconds * FRAMES_PER_SECOND) + (@minutes * FRAMES_PER_MINUTE)
+      other_frames = other.frames + (other.seconds * FRAMES_PER_SECOND) + (other.minutes * FRAMES_PER_MINUTE)
+      frames = my_frames - other_frames
+
+      seconds, frames = *convert_with_rate(frames, seconds, FRAMES_PER_SECOND)
+      minutes, seconds = *convert_with_rate(seconds, minutes, SECONDS_PER_MINUTE)
+      [minutes, seconds, frames]
+    end
+
+    def convert_with_rate(from, to, rate, step=1)
+      while from >= rate
+        to += step
+        from -= rate
+      end
+      [to, from]
+    end
+
+    def set_from_array!(array)
+      if array.size != 3 || array.any?{|element| !element.is_a?(Integer)}
+        raise ArgumentError.new("Must be initialized with an array in the format of [minutes, seconds,frames], all integers")
+      end
+      @minutes, @seconds, @frames = *array
+    end
+
+    def set_from_integer!(seconds)
+      @minutes = 0
+      @frames = 0
+      @seconds = seconds
+
+      while @seconds >= SECONDS_PER_MINUTE
+        @minutes += 1
+        @seconds -= SECONDS_PER_MINUTE
+      end
+    end
+
+  end
+end

data/lib/CatFlac/vendor/rubycue-master/lib/rubycue.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), "rubycue")
+
+require 'cuesheet'
+require 'index'
+require 'exceptions'

data/lib/CatFlac/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CatFlac
+  VERSION = "0.0.1"
+end

data/lib/cat_flac.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "CatFlac/**/*.rb")].sort.each { |file| require file }
+
+module CatFlac
+  class Error < StandardError; end
+  class ParserError < Error; end
+  class NoMatchingParserError < ParserError; end
+  class APIError < Error; end
+  class CommandError < Error; end
+
+  # Meow-meow
+  def self.cat!(path)
+    albums = Parsers::Base.parse(target_folder_path: path)
+    albums.each { |album| Splitter.split(album) }
+  rescue NoMatchingParserError => e
+    warn(e.message)
+  rescue CommandError, APIError => e
+    warn("External dependency failed: #{e.message}")
+  rescue ParserError => e
+    warn("Parsing failed: #{e.message}")
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: CatFlac
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aleksandr Akhtyrskii
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: streamio-ffmpeg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: CatFlac is an utility that helps you split large lossless audio files
+  into tracks using CUE sheets or experimental AI identification. Still in early development.
+email:
+- alexakhtyrskii@gmail.com
+executables:
+- catflac
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- assets/mascot.png
+- exe/catflac
+- lib/CatFlac/album.rb
+- lib/CatFlac/parsers/_base.rb
+- lib/CatFlac/parsers/_helpers.rb
+- lib/CatFlac/parsers/ai/request.rb
+- lib/CatFlac/parsers/ai_parser.rb
+- lib/CatFlac/parsers/builders/ai_album_builder.rb
+- lib/CatFlac/parsers/builders/cue_album_builder.rb
+- lib/CatFlac/parsers/chapters_parser.rb
+- lib/CatFlac/parsers/cue_parser.rb
+- lib/CatFlac/parsers/embedded_cue_parser.rb
+- lib/CatFlac/splitter.rb
+- lib/CatFlac/track.rb
+- lib/CatFlac/vendor/rubycue-master/LICENSE
+- lib/CatFlac/vendor/rubycue-master/lib/rubycue.rb
+- lib/CatFlac/vendor/rubycue-master/lib/rubycue/cuesheet.rb
+- lib/CatFlac/vendor/rubycue-master/lib/rubycue/exceptions.rb
+- lib/CatFlac/vendor/rubycue-master/lib/rubycue/index.rb
+- lib/CatFlac/version.rb
+- lib/cat_flac.rb
+homepage: https://github.com/lxndr128/CatFlac
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/lxndr128/CatFlac
+  source_code_uri: https://github.com/lxndr128/CatFlac
+  rubygems_mfa_required: 'true'
+  changelog_uri: https://github.com/lxndr128/CatFlac/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: A simple tool for splitting lossless audio files.
+test_files: []