tucue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97054b40943e2128666fdce09762dcc347ed314e8f61cb3af56fb4150379fca5
+  data.tar.gz: d713fe563c046f18a36123afe12d1f1ce5fdcfb33cc56bc7d374ce83ffb7417f
+SHA512:
+  metadata.gz: 4f810dcd87e5ede57616c2672572da421cb98d242af2b22e0e5355f9bf3f7989159d552e0939d02a8c4ce62d0d95fe185d42727371fa9428ce226f8097801174
+  data.tar.gz: 0cf0d7c900293762b8d3a924a12be24679e94e0dc42d26ba382a1666813adfc380c84e857d4f52cf2f8894a6fa70efee68f321ccc0c9c6542866b88f0317df36

data/CLAUDE.md

@@ -0,0 +1,158 @@
+# tucue
+
+## Overview
+
+A Ruby TUI application for playing local audio files, marking specific
+moments, and exporting them.
+
+- **gem name**: `tucue` (a blend of TUI + Cue, pronounced "too-cue")
+- **RubyGems**: publishing is planned (check name availability on rubygems.org)
+
+---
+
+## Conventions
+
+- **Code comments**: English.
+- **README and other distributed docs**: English.
+- **Commit messages**: English.
+- **UI strings**: English.
+
+---
+
+## Features
+
+- [x] Play mp3 / wav files
+- [x] Rewind / fast-forward in 5- and 15-second steps
+- [x] Mark the current position (with an optional label)
+- [x] Export the mark list to a file (CSV / JSON)
+
+---
+
+## Technical approach
+
+### Playback engine
+- Delegate to **mpv** (`brew install mpv` is a prerequisite).
+- Open a Unix socket with `--input-ipc-server` and control it by sending
+  JSON commands from Ruby.
+
+```bash
+mpv --input-ipc-server=/tmp/tucue.sock target.mp3
+```
+
+```ruby
+# Seeking
+socket.puts({ command: ["seek", 15, "relative"] }.to_json)
+socket.puts({ command: ["seek", -5, "relative"] }.to_json)
+
+# Get the current position
+socket.puts({ command: ["get_property", "time-pos"] }.to_json)
+```
+
+IPC notes (see `lib/tucue/player.rb`):
+- Pair requests and responses by `request_id`; skip `event` messages that
+  arrive in between.
+- Guard socket sends with a `Mutex` so callers can share the socket safely.
+- Treat a dropped connection (mpv reaching EOF or exiting) as a clean
+  shutdown rather than an error.
+
+### TUI
+- Built on **curses** (bundled with Ruby).
+- Optionally combine with the **tty-\* family** (`tty-cursor`, `tty-screen`,
+  `tty-box`).
+- The UI uses a `getch` timeout to refresh the playback position
+  periodically instead of a separate poll thread, because curses is not
+  thread-safe. (This differs from the original "sub-thread polling" idea.)
+
+### Export formats
+- CSV (default)
+- JSON (option)
+
+---
+
+## UI sketch
+
+```
+┌─────────────────────────────────┐
+│  File: interview.mp3            │
+│  00:01:23 / 00:45:10  ####----  │
+├─────────────────────────────────┤
+│  [Space] play/pause             │
+│  [<-] -5s   [->] +5s            │
+│  [[] -15s   []] +15s            │
+│  [m] mark   [e] export          │
+│  [q] quit                       │
+├─────────────────────────────────┤
+│  Marks (2)                      │
+│  * 00:01:23 - key point         │
+│  * 00:03:45                     │
+└─────────────────────────────────┘
+```
+
+---
+
+## Key bindings
+
+| Key | Action |
+|---|---|
+| `Space` / `p` | Play / pause |
+| `→` | +5 seconds |
+| `←` | -5 seconds |
+| `]` | +15 seconds |
+| `[` | -15 seconds |
+| `m` | Mark the current position |
+| `e` | Export the marks |
+| `q` | Quit |
+
+---
+
+## Gem layout
+
+```
+tucue/
+├── CLAUDE.md
+├── README.md
+├── LICENSE
+├── tucue.gemspec
+├── Gemfile
+├── bin/
+│   └── tucue          # entry point (CLI command)
+└── lib/
+    ├── tucue.rb       # requires and Tucue::Error
+    └── tucue/
+        ├── version.rb
+        ├── cli.rb     # argument parsing / entry point
+        ├── player.rb  # mpv control
+        ├── ui.rb      # curses TUI
+        └── marker.rb  # mark management / export
+```
+
+---
+
+## Usage
+
+```bash
+bundle exec tucue interview.mp3
+bundle exec tucue --start 01:02:03 interview.mp3
+```
+
+CLI options (parsed in `lib/tucue/cli.rb`):
+- `-s`, `--start TIME` — start playback at `TIME` (`SS`, `MM:SS`, or
+  `HH:MM:SS`). Implemented via mpv's `--start=` and `Player#start_at`.
+- `-v`, `--version`; `-h`, `--help`.
+
+---
+
+## Environment / prerequisites
+
+- macOS (developer environment)
+- Ruby 3.x or later
+- mpv (`brew install mpv`)
+
+---
+
+## Licensing
+
+- tucue's own code is released under the **MIT License**.
+- mpv is GPL/LGPL, but it runs as a **separate process** and is **not
+  bundled** with tucue, so its copyleft does not extend to tucue's source.
+  Do not redistribute mpv binaries inside the gem.

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in tucue.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.16"
+
+gem "standard", "~> 1.3"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 takkanm
+
+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,139 @@
+# tucue
+
+[![CI](https://github.com/takkanm/tucue/actions/workflows/ci.yml/badge.svg)](https://github.com/takkanm/tucue/actions/workflows/ci.yml)
+
+A Ruby TUI application for playing local audio files, marking specific
+moments, and exporting them. Handy for managing cue points in interview
+recordings and similar audio.
+
+The name is a blend of **TUI** and **Cue** (pronounced "too-cue").
+
+```
+┌─────────────────────────────────┐
+│  File: interview.mp3            │
+│  00:01:23 / 00:45:10  ####----  │
+├─────────────────────────────────┤
+│  [Space] play/pause             │
+│  [<-] -5s   [->] +5s            │
+│  [[] -15s   []] +15s            │
+│  [m] mark   [e] export          │
+│  [q] quit                       │
+├─────────────────────────────────┤
+│  Marks (2)                      │
+│  * 00:01:23 - key point         │
+│  * 00:03:45                     │
+└─────────────────────────────────┘
+```
+
+## Features
+
+- Play audio files such as mp3 / wav
+- Rewind and fast-forward in 5- and 15-second steps
+- Mark the current position with an optional label
+- Export the mark list as CSV or JSON
+
+## Requirements
+
+- macOS (developer environment)
+- Ruby 3.x or later
+- [mpv](https://mpv.io/) (used as the playback engine)
+
+```bash
+brew install mpv
+```
+
+## Installation
+
+Clone the repository and run bundle install.
+
+```bash
+git clone https://github.com/takkanm/tucue.git
+cd tucue
+bundle install
+```
+
+## Usage
+
+```bash
+bundle exec tucue interview.mp3
+```
+
+This launches the TUI and starts playback.
+
+### Options
+
+| Option | Description |
+|---|---|
+| `-s`, `--start TIME` | Start playback at `TIME`. Accepts `SS`, `MM:SS`, or `HH:MM:SS` (e.g. `90`, `1:30`, `01:02:03`). |
+| `-v`, `--version` | Show the version. |
+| `-h`, `--help` | Show help. |
+
+```bash
+bundle exec tucue --start 01:02:03 interview.mp3
+```
+
+## Key bindings
+
+| Key | Action |
+|---|---|
+| `Space` / `p` | Play / pause |
+| `→` | +5 seconds |
+| `←` | -5 seconds |
+| `]` | +15 seconds |
+| `[` | -15 seconds |
+| `m` | Mark the current position (prompts for an optional label) |
+| `e` | Export the marks |
+| `q` | Quit |
+
+## Export
+
+Pressing `e` writes the current marks to a `.csv` file named after the
+audio file.
+
+### CSV
+
+```csv
+timestamp,seconds,label
+00:01:23,83.0,key point
+00:03:45,225.5,
+```
+
+### JSON
+
+JSON export is also supported (`Tucue::Marker#export_json`).
+
+```json
+[
+  {
+    "timestamp": "00:01:23",
+    "seconds": 83.0,
+    "label": "key point"
+  },
+  {
+    "timestamp": "00:03:45",
+    "seconds": 225.5,
+    "label": null
+  }
+]
+```
+
+## Architecture
+
+| File | Responsibility |
+|---|---|
+| `bin/tucue` | CLI entry point |
+| `lib/tucue/player.rb` | Playback engine controlling mpv over JSON IPC (Unix socket) |
+| `lib/tucue/ui.rb` | curses-based TUI and key-input loop |
+| `lib/tucue/marker.rb` | Mark management and CSV / JSON export |
+
+mpv is launched with `--input-ipc-server` and controlled by sending JSON
+commands over a Unix domain socket to seek and read the playback position.
+
+## License
+
+tucue is released under the [MIT License](LICENSE).
+
+tucue requires [mpv](https://mpv.io/), which is licensed under
+GPL-2.0-or-later and LGPL-2.1-or-later. mpv runs as a separate process and
+is not distributed with tucue; you install it yourself (e.g. via Homebrew),
+so its copyleft terms do not apply to tucue's own source.

data/bin/tucue

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/tucue"
+
+exit Tucue::CLI.start(ARGV)

data/lib/tucue/cli.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Tucue
+  # Command-line entry point: parses arguments and launches the TUI.
+  class CLI
+    # Run with the given argv. Returns a process exit status (0 = success).
+    def self.start(argv)
+      new.start(argv)
+    end
+
+    def start(argv)
+      options = parse(argv)
+      file = argv.shift
+
+      unless file
+        warn "usage: tucue [options] FILE"
+        return 1
+      end
+
+      unless File.exist?(file)
+        warn "tucue: file not found: #{file}"
+        return 1
+      end
+
+      player = Player.new(file, start_at: options[:start_at])
+      marker = Marker.new
+      UI.new(player, marker).run
+      0
+    rescue OptionParser::ParseError, ArgumentError => e
+      warn "tucue: #{e.message}"
+      1
+    end
+
+    # Parse "SS", "MM:SS", or "HH:MM:SS" (seconds may be fractional) into a
+    # number of seconds. Returns nil for nil input; raises ArgumentError on a
+    # malformed value.
+    def self.parse_time(value)
+      return nil if value.nil?
+
+      parts = value.to_s.split(":", -1)
+      unless (1..3).cover?(parts.size) && parts.all? { |p| p.match?(/\A\d+(\.\d+)?\z/) }
+        raise ArgumentError, "invalid time: #{value.inspect} (use SS, MM:SS, or HH:MM:SS)"
+      end
+
+      parts.map(&:to_f).reduce(0.0) { |acc, part| acc * 60 + part }
+    end
+
+    private
+
+    def parse(argv)
+      options = {}
+      parser = OptionParser.new do |o|
+        o.banner = "usage: tucue [options] FILE"
+        o.on("-s", "--start TIME", "Start playback at TIME (e.g. 90, 1:30, 01:02:03)") do |v|
+          options[:start_at] = self.class.parse_time(v)
+        end
+        o.on("-v", "--version", "Show version") do
+          puts Tucue::VERSION
+          exit 0
+        end
+        o.on("-h", "--help", "Show this help") do
+          puts o
+          exit 0
+        end
+      end
+      parser.parse!(argv)
+      options
+    end
+  end
+end

data/lib/tucue/marker.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "csv"
+require "json"
+
+module Tucue
+  # Records marks and exports them to CSV / JSON.
+  class Marker
+    # A single mark: +time+ is the playback position in seconds and
+    # +label+ is an optional user-supplied note.
+    Mark = Struct.new(:time, :label) do
+      # Format the time as HH:MM:SS.
+      def timestamp
+        total = time.to_i
+        format("%02d:%02d:%02d", total / 3600, (total % 3600) / 60, total % 60)
+      end
+
+      def to_h
+        {timestamp: timestamp, seconds: time.to_f.round(3), label: label}
+      end
+    end
+
+    CSV_HEADERS = %w[timestamp seconds label].freeze
+
+    def initialize
+      @marks = []
+    end
+
+    attr_reader :marks
+
+    # Append a mark at +time+ seconds with an optional +label+.
+    def add(time, label = nil)
+      label = nil if label.is_a?(String) && label.strip.empty?
+      mark = Mark.new(time, label)
+      @marks << mark
+      mark
+    end
+
+    def empty?
+      @marks.empty?
+    end
+
+    # Write the marks to +path+ as CSV and return the path.
+    def export_csv(path)
+      CSV.open(path, "w") do |csv|
+        csv << CSV_HEADERS
+        @marks.each do |mark|
+          csv << [mark.timestamp, mark.time.to_f.round(3), mark.label]
+        end
+      end
+      path
+    end
+
+    # Write the marks to +path+ as JSON and return the path.
+    def export_json(path)
+      File.write(path, JSON.pretty_generate(@marks.map(&:to_h)))
+      path
+    end
+  end
+end

data/lib/tucue/player.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+require "timeout"
+
+module Tucue
+  # Playback engine that controls mpv over --input-ipc-server.
+  #
+  # Spawns mpv as a child process and talks to it through a Unix domain
+  # socket, sending JSON IPC commands to seek and read the playback position.
+  # https://mpv.io/manual/stable/#json-ipc
+  class Player
+    class Error < Tucue::Error; end
+
+    # Max seconds to wait for the IPC socket to appear.
+    SOCKET_TIMEOUT = 5
+
+    def initialize(file, socket_path: "/tmp/tucue.sock", start_at: nil, extra_args: [])
+      @file = file
+      @socket_path = socket_path
+      @start_at = start_at
+      @extra_args = extra_args
+      @pid = nil
+      @socket = nil
+      @request_id = 0
+      @mutex = Mutex.new
+    end
+
+    attr_reader :file
+
+    # Launch mpv and connect to its IPC socket.
+    def start
+      raise Error, "mpv not found in PATH" unless mpv_available?
+
+      File.unlink(@socket_path) if File.exist?(@socket_path)
+
+      @pid = spawn(
+        "mpv",
+        "--no-video",
+        "--no-terminal",
+        "--input-ipc-server=#{@socket_path}",
+        *(@start_at ? ["--start=#{@start_at}"] : []),
+        *@extra_args,
+        @file
+      )
+
+      connect
+      self
+    end
+
+    # Toggle between playing and paused.
+    def toggle_pause
+      command("cycle", "pause")
+    end
+
+    def play
+      set_property("pause", false)
+    end
+
+    def pause
+      set_property("pause", true)
+    end
+
+    def paused?
+      get_property("pause") == true
+    end
+
+    # Seek relative to the current position (seconds; negative rewinds).
+    def seek(seconds)
+      command("seek", seconds, "relative")
+    end
+
+    # Current playback position in seconds, or nil if unavailable.
+    def time_pos
+      get_property("time-pos")
+    end
+
+    # Total duration in seconds, or nil if unavailable.
+    def duration
+      get_property("duration")
+    end
+
+    # Quit mpv and close the socket.
+    def stop
+      command("quit") if @socket
+    rescue Error
+      # Already gone; ignore.
+    ensure
+      close
+    end
+
+    private
+
+    def mpv_available?
+      ENV["PATH"].to_s.split(File::PATH_SEPARATOR).any? do |dir|
+        File.executable?(File.join(dir, "mpv"))
+      end
+    end
+
+    def connect
+      Timeout.timeout(SOCKET_TIMEOUT) do
+        loop do
+          break if File.socket?(@socket_path)
+
+          sleep 0.05
+        end
+
+        loop do
+          @socket = UNIXSocket.new(@socket_path)
+          break
+        rescue Errno::ENOENT, Errno::ECONNREFUSED
+          sleep 0.05
+        end
+      end
+    rescue Timeout::Error
+      raise Error, "timed out waiting for mpv IPC socket: #{@socket_path}"
+    end
+
+    # Send a command whose return value we don't care about.
+    def command(*args)
+      send_command(args)["error"] == "success"
+    end
+
+    def get_property(name)
+      response = send_command(["get_property", name])
+      (response["error"] == "success") ? response["data"] : nil
+    end
+
+    def set_property(name, value)
+      command("set_property", name, value)
+    end
+
+    # Send a JSON IPC command and return the matching response.
+    # Requests and responses are paired by request_id; event messages
+    # arriving in between are skipped.
+    def send_command(args)
+      raise Error, "player not started" unless @socket
+
+      @mutex.synchronize do
+        id = (@request_id += 1)
+        @socket.puts(JSON.generate(command: args, request_id: id))
+
+        loop do
+          line = @socket.gets
+          raise Error, "mpv connection closed" if line.nil?
+
+          message = JSON.parse(line)
+          return message if message["request_id"] == id
+          # Anything else (events, etc.) is ignored.
+        end
+      end
+    rescue Errno::EPIPE, IOError => e
+      raise Error, "mpv IPC error: #{e.message}"
+    end
+
+    def close
+      @socket&.close
+      @socket = nil
+      if @pid
+        Process.wait(@pid)
+      end
+    rescue Errno::ECHILD, Errno::ESRCH
+      # Already reaped.
+    ensure
+      @pid = nil
+      File.unlink(@socket_path) if File.exist?(@socket_path)
+    end
+  end
+end

data/lib/tucue/ui.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "curses"
+
+module Tucue
+  # curses-based TUI handling the key-input loop and screen drawing.
+  #
+  # Rather than spawning a separate poll thread (curses is not thread-safe),
+  # the main loop uses a getch timeout so the screen refreshes periodically
+  # while still reacting to key presses promptly.
+  class UI
+    SEEK_SMALL = 5
+    SEEK_LARGE = 15
+
+    # getch timeout in ms; also the screen refresh interval.
+    REFRESH_MS = 200
+
+    PROGRESS_WIDTH = 24
+
+    def initialize(player, marker)
+      @player = player
+      @marker = marker
+      @status = ""
+      @running = true
+    end
+
+    def run
+      @player.start
+      @status = "Playing #{File.basename(@player.file)}"
+      with_curses do
+        loop do
+          begin
+            draw
+            handle_key(@window.getch)
+          rescue Tucue::Error => e
+            # The player connection dropped (e.g. mpv reached end of file
+            # or exited); report it and leave the loop cleanly.
+            @status = "Playback ended: #{e.message}"
+            @running = false
+          end
+          break unless @running
+        end
+      end
+    ensure
+      @player.stop
+    end
+
+    private
+
+    def with_curses
+      Curses.init_screen
+      Curses.curs_set(0)
+      Curses.noecho
+      Curses.stdscr.keypad(true)
+      @window = Curses.stdscr
+      @window.timeout = REFRESH_MS
+      yield
+    ensure
+      Curses.close_screen
+    end
+
+    def handle_key(key)
+      case key
+      when " ", "p"
+        @player.toggle_pause
+        @status = @player.paused? ? "Paused" : "Playing"
+      when Curses::Key::RIGHT
+        @player.seek(SEEK_SMALL)
+      when Curses::Key::LEFT
+        @player.seek(-SEEK_SMALL)
+      when "]"
+        @player.seek(SEEK_LARGE)
+      when "["
+        @player.seek(-SEEK_LARGE)
+      when "m"
+        add_mark
+      when "e"
+        export
+      when "q"
+        @running = false
+      end
+    rescue Tucue::Error => e
+      @status = "Error: #{e.message}"
+    end
+
+    def add_mark
+      pos = @player.time_pos || 0
+      label = prompt("Label (optional): ")
+      label = nil if label.empty?
+      @marker.add(pos, label)
+      @status = "Marked #{format_time(pos)}#{" - #{label}" if label}"
+    end
+
+    def export
+      path = "#{File.basename(@player.file, ".*")}.csv"
+      @marker.export_csv(path)
+      @status = "Exported #{@marker.marks.size} mark(s) to #{path}"
+    rescue NotImplementedError
+      @status = "Export not implemented yet"
+    end
+
+    # Read a line of input at the bottom of the screen.
+    def prompt(message)
+      Curses.curs_set(1)
+      Curses.echo
+      @window.setpos(@window.maxy - 1, 0)
+      @window.clrtoeol
+      @window.addstr(message)
+      @window.timeout = -1 # block until the user finishes typing
+      input = @window.getstr.to_s.strip
+      input
+    ensure
+      @window.timeout = REFRESH_MS
+      Curses.noecho
+      Curses.curs_set(0)
+    end
+
+    def draw
+      @window.erase
+      row = 0
+      @window.setpos(row, 0)
+      @window.addstr("  File: #{File.basename(@player.file)}")
+
+      row += 1
+      pos = @player.time_pos
+      dur = @player.duration
+      @window.setpos(row, 0)
+      @window.addstr("  #{format_time(pos)} / #{format_time(dur)}  #{progress_bar(pos, dur)}")
+
+      row += 1
+      @window.setpos(row, 0)
+      @window.addstr("  " + ("-" * 40))
+
+      [
+        "[Space] play/pause",
+        "[<-] -#{SEEK_SMALL}s   [->] +#{SEEK_SMALL}s",
+        "[[] -#{SEEK_LARGE}s   []] +#{SEEK_LARGE}s",
+        "[m] mark   [e] export",
+        "[q] quit"
+      ].each do |line|
+        row += 1
+        @window.setpos(row, 0)
+        @window.addstr("  #{line}")
+      end
+
+      row += 1
+      @window.setpos(row, 0)
+      @window.addstr("  " + ("-" * 40))
+
+      row += 1
+      @window.setpos(row, 0)
+      @window.addstr("  Marks (#{@marker.marks.size})")
+
+      @marker.marks.each do |mark|
+        row += 1
+        break if row >= @window.maxy - 1
+
+        label = mark.label ? " - #{mark.label}" : ""
+        @window.setpos(row, 0)
+        @window.addstr("  * #{format_time(mark.time)}#{label}")
+      end
+
+      @window.setpos(@window.maxy - 1, 0)
+      @window.addstr("  #{@status}")
+      @window.refresh
+    end
+
+    def progress_bar(pos, dur)
+      return "-" * PROGRESS_WIDTH unless pos && dur&.positive?
+
+      filled = [(pos.to_f / dur * PROGRESS_WIDTH).round, PROGRESS_WIDTH].min
+      ("#" * filled) + ("-" * (PROGRESS_WIDTH - filled))
+    end
+
+    # Format seconds as HH:MM:SS.
+    def format_time(seconds)
+      return "--:--:--" if seconds.nil?
+
+      total = seconds.to_i
+      format("%02d:%02d:%02d", total / 3600, (total % 3600) / 60, total % 60)
+    end
+  end
+end

data/lib/tucue/version.rb

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

data/lib/tucue.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "tucue/version"
+
+module Tucue
+  class Error < StandardError; end
+end
+
+require_relative "tucue/player"
+require_relative "tucue/marker"
+require_relative "tucue/ui"
+require_relative "tucue/cli"

data/tucue.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "lib/tucue/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "tucue"
+  spec.version = Tucue::VERSION
+  spec.authors = ["takkanm"]
+  spec.email = ["takkanm@gmail.com"]
+
+  spec.summary = "TUI audio player for marking and exporting cue points."
+  spec.description = "tucue plays local audio files (mp3/wav) in a terminal UI, " \
+                       "lets you mark timestamps with optional labels, and export " \
+                       "them as CSV or JSON. Playback is delegated to mpv."
+  spec.homepage = "https://github.com/takkanm/tucue"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files = Dir["lib/**/*.rb", "bin/*", "*.gemspec", "Gemfile", "README.md", "LICENSE", "CLAUDE.md"]
+  spec.bindir = "bin"
+  spec.executables = ["tucue"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "csv", "~> 3.0"
+  spec.add_dependency "curses", "~> 1.4"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: tucue
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- takkanm
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: csv
+  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: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: tucue plays local audio files (mp3/wav) in a terminal UI, lets you mark
+  timestamps with optional labels, and export them as CSV or JSON. Playback is delegated
+  to mpv.
+email:
+- takkanm@gmail.com
+executables:
+- tucue
+extensions: []
+extra_rdoc_files: []
+files:
+- CLAUDE.md
+- Gemfile
+- LICENSE
+- README.md
+- bin/tucue
+- lib/tucue.rb
+- lib/tucue/cli.rb
+- lib/tucue/marker.rb
+- lib/tucue/player.rb
+- lib/tucue/ui.rb
+- lib/tucue/version.rb
+- tucue.gemspec
+homepage: https://github.com/takkanm/tucue
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/takkanm/tucue
+  source_code_uri: https://github.com/takkanm/tucue
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: TUI audio player for marking and exporting cue points.
+test_files: []