pylonite 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5262454e6d454011d45404697730c9992dfaf2a8a1ae0abba675e1b32f2ad8d1
+  data.tar.gz: 2de33c973493ffb5564ba2226eec960715a26dad13f79a230bf653c4b46588d8
+SHA512:
+  metadata.gz: 757a919ecaad96c2b920fad316c6598ca3126a7cf77435169097670807cbab693389e0a93b564e2edf78b99a05d35b6041f504218eaaa4741e97bc8d3e592657
+  data.tar.gz: d3e379a348b3d84a19a3bf1c001e0838ab0a2c2b174051e6dca22c347badb11606cfaf81f78472163014c9a804571858752e2502875e3b43b5191efd180e149b

data/bin/pylonite

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/pylonite"
+
+Pylonite::CLI.run(ARGV)

data/lib/pylonite/cli.rb

@@ -0,0 +1,325 @@
+module Pylonite
+  module CLI
+    BOARD_COLORS = {
+      "backlog" => "\e[37m",
+      "todo" => "\e[33m",
+      "in_progress" => "\e[36m",
+      "done" => "\e[32m",
+      "archived" => "\e[90m"
+    }.freeze
+
+    RESET = "\e[0m"
+    BOLD = "\e[1m"
+    DIM = "\e[2m"
+
+    def self.run(args)
+      command = args.shift
+      case command
+      when "add" then cmd_add(args)
+      when "show" then cmd_show(args)
+      when "list" then cmd_list(args)
+      when "move" then cmd_move(args)
+      when "comment" then cmd_comment(args)
+      when "search" then cmd_search(args)
+      when "archive" then cmd_archive(args)
+      when "assign" then cmd_assign(args)
+      when "block" then cmd_block(args)
+      when "unblock" then cmd_unblock(args)
+      when "subtask" then cmd_subtask(args)
+      when "edit" then cmd_edit(args)
+      when "log" then cmd_log(args)
+      when "internal" then cmd_internal(args)
+      when "tui" then Pylonite::TUI.run
+      when "help", "--help", "-h", nil then Pylonite::Help.display
+      else
+        error("Unknown command: #{command}. Run 'pylonite help' for usage.")
+      end
+    rescue => e
+      error(e.message)
+    end
+
+    # --- Commands ---
+
+    def self.cmd_add(args)
+      board = extract_option(args, "--board") || "backlog"
+      assignee = extract_option(args, "--assign")
+      description = extract_option(args, "--description") || extract_option(args, "-d")
+      title = args.first
+      error("Usage: pylonite add \"task title\" [--board BOARD] [--assign USER] [--description TEXT]") unless title
+
+      db = Database.new
+      id = db.add_task(title, board: board, assignee: assignee, description: description)
+      puts "Created task #{BOLD}##{id}#{RESET} in #{colorize_board(board)}"
+    end
+
+    def self.cmd_show(args)
+      id = args.first&.to_i
+      error("Usage: pylonite show ID") unless id && id > 0
+
+      db = Database.new
+      task = db.get_task(id)
+      error("Task ##{id} not found") unless task
+
+      board = task["board"]
+      puts "#{BOLD}##{task["id"]}#{RESET} #{task["title"]}"
+      puts "  Board:    #{colorize_board(board)}"
+      puts "  Author:   #{task["author"]}" if task["author"]
+      puts "  Assignee: #{task["assignee"]}" if task["assignee"]
+      puts "  Created:  #{task["created_at"]}"
+      puts "  Updated:  #{task["updated_at"]}"
+
+      if task["parent"]
+        puts "  Parent:   ##{task["parent"]["id"]} #{task["parent"]["title"]}"
+      end
+
+      if task["description"] && !task["description"].empty?
+        puts ""
+        puts "  #{DIM}Description:#{RESET}"
+        task["description"].each_line { |l| puts "    #{l.rstrip}" }
+      end
+
+      if task["blockers"] && !task["blockers"].empty?
+        puts ""
+        puts "  #{DIM}Blocked by:#{RESET}"
+        task["blockers"].each do |b|
+          puts "    ##{b["id"]} #{b["title"]} [#{b["board"]}]"
+        end
+      end
+
+      if task["blocked_by_this"] && !task["blocked_by_this"].empty?
+        puts ""
+        puts "  #{DIM}Blocking:#{RESET}"
+        task["blocked_by_this"].each do |b|
+          puts "    ##{b["id"]} #{b["title"]} [#{b["board"]}]"
+        end
+      end
+
+      if task["subtasks"] && !task["subtasks"].empty?
+        puts ""
+        puts "  #{DIM}Subtasks:#{RESET}"
+        task["subtasks"].each do |s|
+          puts "    ##{s["id"]} #{s["title"]} [#{s["board"]}]"
+        end
+      end
+
+      if task["comments"] && !task["comments"].empty?
+        puts ""
+        puts "  #{DIM}Comments:#{RESET}"
+        task["comments"].each do |c|
+          puts "    #{DIM}#{c["created_at"]} #{c["author"]}:#{RESET} #{c["text"]}"
+        end
+      end
+
+      if task["history"] && !task["history"].empty?
+        puts ""
+        puts "  #{DIM}History:#{RESET}"
+        task["history"].each do |h|
+          puts "    #{DIM}#{h["created_at"]}#{RESET} #{h["actor"]}: #{h["detail"]}"
+        end
+      end
+    end
+
+    def self.cmd_list(args)
+      board = extract_option(args, "--board")
+      include_all = args.delete("--all")
+
+      db = Database.new
+      tasks = db.list_tasks(board: board, include_archived: !!include_all)
+
+      if tasks.empty?
+        puts "No tasks found."
+        return
+      end
+
+      grouped = tasks.group_by { |t| t["board"] }
+      board_order = Database::BOARDS
+
+      board_order.each do |b|
+        next unless grouped[b]
+        color = BOARD_COLORS[b] || ""
+        puts "#{color}#{BOLD}#{b.upcase.tr("_", " ")}#{RESET}"
+        grouped[b].each do |t|
+          assignee_str = t["assignee"] ? " #{DIM}(#{t["assignee"]})#{RESET}" : ""
+          puts "  #{color}##{t["id"]}#{RESET} #{t["title"]}#{assignee_str}"
+        end
+        puts ""
+      end
+    end
+
+    def self.cmd_move(args)
+      id = args.shift&.to_i
+      board = args.shift
+      error("Usage: pylonite move ID BOARD") unless id && id > 0 && board
+
+      db = Database.new
+      db.move_task(id, board)
+      puts "Moved task #{BOLD}##{id}#{RESET} to #{colorize_board(board)}"
+    end
+
+    def self.cmd_comment(args)
+      id = args.shift&.to_i
+      text = args.first
+      error("Usage: pylonite comment ID \"comment text\"") unless id && id > 0 && text
+
+      db = Database.new
+      db.add_comment(id, text)
+      puts "Comment added to task #{BOLD}##{id}#{RESET}"
+    end
+
+    def self.cmd_search(args)
+      query = args.first
+      error("Usage: pylonite search \"query\"") unless query
+
+      db = Database.new
+      tasks = db.search_tasks(query)
+
+      if tasks.empty?
+        puts "No tasks matching \"#{query}\"."
+        return
+      end
+
+      tasks.each do |t|
+        color = BOARD_COLORS[t["board"]] || ""
+        assignee_str = t["assignee"] ? " #{DIM}(#{t["assignee"]})#{RESET}" : ""
+        puts "#{color}##{t["id"]}#{RESET} #{t["title"]} [#{t["board"]}]#{assignee_str}"
+      end
+    end
+
+    def self.cmd_archive(args)
+      id = args.first&.to_i
+      error("Usage: pylonite archive ID") unless id && id > 0
+
+      db = Database.new
+      db.archive_task(id)
+      puts "Archived task #{BOLD}##{id}#{RESET}"
+    end
+
+    def self.cmd_assign(args)
+      id = args.shift&.to_i
+      user = args.first
+      error("Usage: pylonite assign ID USER") unless id && id > 0 && user
+
+      db = Database.new
+      db.assign_task(id, user)
+      puts "Assigned task #{BOLD}##{id}#{RESET} to #{user}"
+    end
+
+    def self.cmd_block(args)
+      id = args.shift&.to_i
+      blocker_id = args.first&.to_i
+      error("Usage: pylonite block ID BLOCKER_ID") unless id && id > 0 && blocker_id && blocker_id > 0
+
+      db = Database.new
+      db.add_blocker(id, blocker_id)
+      puts "Task #{BOLD}##{blocker_id}#{RESET} now blocks #{BOLD}##{id}#{RESET}"
+    end
+
+    def self.cmd_unblock(args)
+      id = args.shift&.to_i
+      blocker_id = args.first&.to_i
+      error("Usage: pylonite unblock ID BLOCKER_ID") unless id && id > 0 && blocker_id && blocker_id > 0
+
+      db = Database.new
+      db.remove_blocker(id, blocker_id)
+      puts "Removed blocker #{BOLD}##{blocker_id}#{RESET} from #{BOLD}##{id}#{RESET}"
+    end
+
+    def self.cmd_subtask(args)
+      parent_id = args.shift&.to_i
+      title = args.first
+      error("Usage: pylonite subtask PARENT_ID \"title\"") unless parent_id && parent_id > 0 && title
+
+      db = Database.new
+      id = db.add_subtask(parent_id, title)
+      puts "Created subtask #{BOLD}##{id}#{RESET} under #{BOLD}##{parent_id}#{RESET}"
+    end
+
+    def self.cmd_edit(args)
+      id = args.shift&.to_i
+      error("Usage: pylonite edit ID [--title \"new title\"] [--description \"new desc\"]") unless id && id > 0
+
+      title = extract_option(args, "--title")
+      description = extract_option(args, "--description") || extract_option(args, "-d")
+      error("Nothing to update. Use --title or --description / -d") unless title || description
+
+      db = Database.new
+      db.update_task(id, title: title, description: description)
+      puts "Updated task #{BOLD}##{id}#{RESET}"
+    end
+
+    def self.cmd_log(args)
+      db = Database.new
+      entries = db.activity_log
+
+      if entries.empty?
+        puts "No activity yet."
+        return
+      end
+
+      output = entries.map do |e|
+        "#{DIM}#{e["created_at"]}#{RESET} #{e["actor"]} #{format_action(e["action"])} #{BOLD}##{e["task_id"]}#{RESET} #{e["title"]}\n    #{DIM}#{e["detail"]}#{RESET}"
+      end.join("\n\n") + "\n"
+
+      if $stdout.tty?
+        pager = ENV["PAGER"] || "less -R"
+        IO.popen(pager, "w") { |io| io.write(output) }
+      else
+        $stdout.write(output)
+      end
+    rescue Errno::EPIPE
+      # user quit pager early
+    end
+
+    def self.format_action(action)
+      case action
+      when "created" then "created"
+      when "moved" then "moved"
+      when "assigned" then "assigned"
+      when "commented" then "commented on"
+      when "updated" then "updated"
+      when "blocker_added" then "added blocker to"
+      when "blocker_removed" then "removed blocker from"
+      when "subtask_added" then "added subtask to"
+      when "subtask_created" then "created subtask"
+      else action.tr("_", " ")
+      end
+    end
+
+    def self.cmd_internal(args)
+      subcommand = args.shift
+      case subcommand
+      when "appropriate"
+        old_path = args.first
+        error("Usage: pylonite internal appropriate OLD_DB_PATH") unless old_path
+        new_path = Database.appropriate(Dir.pwd, old_path)
+        puts "Database moved to #{new_path}"
+      else
+        error("Unknown internal command: #{subcommand}")
+      end
+    end
+
+    # --- Helpers ---
+
+    def self.extract_option(args, flag)
+      idx = args.index(flag)
+      return nil unless idx
+      args.delete_at(idx)
+      args.delete_at(idx)
+    end
+
+    def self.colorize_board(board)
+      color = BOARD_COLORS[board] || ""
+      "#{color}#{board}#{RESET}"
+    end
+
+    def self.error(message)
+      $stderr.puts "Error: #{message}"
+      exit(1)
+    end
+
+    private_class_method :extract_option, :colorize_board, :error, :format_action,
+      :cmd_add, :cmd_show, :cmd_list, :cmd_move, :cmd_comment,
+      :cmd_search, :cmd_archive, :cmd_assign, :cmd_block, :cmd_unblock,
+      :cmd_subtask, :cmd_edit, :cmd_log, :cmd_internal
+  end
+end

data/lib/pylonite/database.rb

@@ -0,0 +1,346 @@
+require "sqlite3"
+require "fileutils"
+require "digest"
+
+module Pylonite
+  class Database
+    BOARDS = %w[backlog todo in_progress done archived].freeze
+    DEFAULT_DB_DIR = File.expand_path("~/.pylonite/dbs")
+
+    def self.db_dir
+      @db_dir || DEFAULT_DB_DIR
+    end
+
+    def self.db_dir=(dir)
+      @db_dir = dir
+    end
+
+    attr_reader :db, :db_path
+
+    def initialize(project_path = Dir.pwd)
+      @db_path = self.class.db_path_for(project_path)
+      FileUtils.mkdir_p(File.dirname(@db_path))
+      @db = SQLite3::Database.new(@db_path)
+      @db.results_as_hash = true
+      @db.execute("PRAGMA journal_mode=WAL")
+      @db.execute("PRAGMA foreign_keys=ON")
+      migrate!
+    end
+
+    def self.db_name_for(project_path)
+      name = File.basename(project_path)
+      hash = Digest::SHA256.hexdigest(project_path)[0, 8]
+      "#{name}_#{hash}"
+    end
+
+    def self.db_path_for(project_path)
+      File.join(db_dir, "#{db_name_for(project_path)}.sqlite3")
+    end
+
+    def self.appropriate(new_path, old_db_path)
+      raise "Database not found: #{old_db_path}" unless File.exist?(old_db_path)
+
+      new_db_path = db_path_for(new_path)
+      if File.expand_path(old_db_path) == File.expand_path(new_db_path)
+        return new_db_path
+      end
+      FileUtils.mkdir_p(File.dirname(new_db_path))
+      FileUtils.mv(old_db_path, new_db_path)
+      new_db_path
+    end
+
+    # --- Tasks ---
+
+    def add_task(title, author: nil, board: "backlog", assignee: nil, description: nil)
+      author ||= current_user
+      now = Time.now.utc.iso8601
+      @db.execute(
+        "INSERT INTO tasks (title, description, board, author, assignee, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+        [title, description, board, author, assignee, now, now]
+      )
+      task_id = @db.last_insert_row_id
+      record_history(task_id, author, "created", "Created task in #{board}")
+      task_id
+    end
+
+    def get_task(task_id)
+      task = @db.get_first_row("SELECT * FROM tasks WHERE id = ?", [task_id])
+      return nil unless task
+
+      task["comments"] = get_comments(task_id)
+      task["history"] = get_history(task_id)
+      task["blockers"] = get_blockers(task_id)
+      task["blocked_by_this"] = get_blocked_by_this(task_id)
+      task["subtasks"] = get_subtasks(task_id)
+      task["parent"] = get_parent(task_id)
+      task
+    end
+
+    def list_tasks(board: nil, include_archived: false)
+      if board
+        @db.execute("SELECT * FROM tasks WHERE board = ? ORDER BY updated_at DESC", [board])
+      elsif include_archived
+        @db.execute("SELECT * FROM tasks ORDER BY board, updated_at DESC")
+      else
+        @db.execute("SELECT * FROM tasks WHERE board != 'archived' ORDER BY board, updated_at DESC")
+      end
+    end
+
+    def move_task(task_id, new_board, actor: nil)
+      actor ||= current_user
+      raise "Invalid board: #{new_board}. Valid boards: #{BOARDS.join(', ')}" unless BOARDS.include?(new_board)
+
+      task = get_task(task_id)
+      raise "Task ##{task_id} not found" unless task
+
+      old_board = task["board"]
+      now = Time.now.utc.iso8601
+      @db.execute("UPDATE tasks SET board = ?, updated_at = ? WHERE id = ?", [new_board, now, task_id])
+      record_history(task_id, actor, "moved", "Moved from #{old_board} to #{new_board}")
+    end
+
+    def archive_task(task_id, actor: nil)
+      move_task(task_id, "archived", actor: actor)
+    end
+
+    def assign_task(task_id, assignee, actor: nil)
+      actor ||= current_user
+      task = get_task(task_id)
+      raise "Task ##{task_id} not found" unless task
+
+      now = Time.now.utc.iso8601
+      @db.execute("UPDATE tasks SET assignee = ?, updated_at = ? WHERE id = ?", [assignee, now, task_id])
+      record_history(task_id, actor, "assigned", "Assigned to #{assignee}")
+    end
+
+    def update_task(task_id, title: nil, description: nil, actor: nil)
+      actor ||= current_user
+      task = get_task(task_id)
+      raise "Task ##{task_id} not found" unless task
+
+      updates = []
+      params = []
+      if title
+        updates << "title = ?"
+        params << title
+      end
+      if description
+        updates << "description = ?"
+        params << description
+      end
+      return if updates.empty?
+
+      updates << "updated_at = ?"
+      params << Time.now.utc.iso8601
+      params << task_id
+      @db.execute("UPDATE tasks SET #{updates.join(', ')} WHERE id = ?", params)
+      record_history(task_id, actor, "updated", "Updated task details")
+    end
+
+    def search_tasks(query)
+      @db.execute(
+        "SELECT * FROM tasks WHERE title LIKE ? OR description LIKE ? ORDER BY updated_at DESC",
+        ["%#{query}%", "%#{query}%"]
+      )
+    end
+
+    # --- Comments ---
+
+    def add_comment(task_id, text, author: nil)
+      author ||= current_user
+      task = get_task(task_id)
+      raise "Task ##{task_id} not found" unless task
+
+      now = Time.now.utc.iso8601
+      @db.execute(
+        "INSERT INTO comments (task_id, author, text, created_at) VALUES (?, ?, ?, ?)",
+        [task_id, author, text, now]
+      )
+      @db.execute("UPDATE tasks SET updated_at = ? WHERE id = ?", [now, task_id])
+      record_history(task_id, author, "commented", "Added a comment")
+      @db.last_insert_row_id
+    end
+
+    def get_comments(task_id)
+      @db.execute("SELECT * FROM comments WHERE task_id = ? ORDER BY created_at ASC", [task_id])
+    end
+
+    # --- Dependencies ---
+
+    def add_blocker(task_id, blocker_id, actor: nil)
+      actor ||= current_user
+      raise "Task cannot block itself" if task_id == blocker_id
+      raise "Task ##{task_id} not found" unless get_task_raw(task_id)
+      raise "Task ##{blocker_id} not found" unless get_task_raw(blocker_id)
+
+      @db.execute(
+        "INSERT OR IGNORE INTO task_dependencies (task_id, depends_on_id, dependency_type) VALUES (?, ?, 'blocks')",
+        [task_id, blocker_id]
+      )
+      record_history(task_id, actor, "blocker_added", "Added blocker: task ##{blocker_id}")
+    end
+
+    def remove_blocker(task_id, blocker_id, actor: nil)
+      actor ||= current_user
+      @db.execute(
+        "DELETE FROM task_dependencies WHERE task_id = ? AND depends_on_id = ? AND dependency_type = 'blocks'",
+        [task_id, blocker_id]
+      )
+      record_history(task_id, actor, "blocker_removed", "Removed blocker: task ##{blocker_id}")
+    end
+
+    def get_blockers(task_id)
+      @db.execute(
+        "SELECT t.* FROM tasks t JOIN task_dependencies d ON d.depends_on_id = t.id WHERE d.task_id = ? AND d.dependency_type = 'blocks'",
+        [task_id]
+      )
+    end
+
+    def get_blocked_by_this(task_id)
+      @db.execute(
+        "SELECT t.* FROM tasks t JOIN task_dependencies d ON d.task_id = t.id WHERE d.depends_on_id = ? AND d.dependency_type = 'blocks'",
+        [task_id]
+      )
+    end
+
+    # --- Subtasks ---
+
+    def add_subtask(parent_id, title, author: nil)
+      author ||= current_user
+      raise "Task ##{parent_id} not found" unless get_task_raw(parent_id)
+
+      task_id = add_task(title, author: author)
+      @db.execute(
+        "INSERT INTO task_dependencies (task_id, depends_on_id, dependency_type) VALUES (?, ?, 'subtask')",
+        [task_id, parent_id]
+      )
+      record_history(task_id, author, "subtask_created", "Created as subtask of ##{parent_id}")
+      record_history(parent_id, author, "subtask_added", "Added subtask ##{task_id}")
+      task_id
+    end
+
+    def get_subtasks(task_id)
+      @db.execute(
+        "SELECT t.* FROM tasks t JOIN task_dependencies d ON d.task_id = t.id WHERE d.depends_on_id = ? AND d.dependency_type = 'subtask'",
+        [task_id]
+      )
+    end
+
+    def get_parent(task_id)
+      @db.get_first_row(
+        "SELECT t.* FROM tasks t JOIN task_dependencies d ON d.depends_on_id = t.id WHERE d.task_id = ? AND d.dependency_type = 'subtask'",
+        [task_id]
+      )
+    end
+
+    # --- History ---
+
+    def get_history(task_id)
+      @db.execute("SELECT * FROM task_history WHERE task_id = ? ORDER BY created_at ASC", [task_id])
+    end
+
+    def activity_log
+      @db.execute(<<~SQL)
+        SELECT h.created_at, h.actor, h.action, h.detail, h.task_id, t.title
+        FROM task_history h
+        JOIN tasks t ON t.id = h.task_id
+        ORDER BY h.created_at DESC, h.id DESC
+      SQL
+    end
+
+    def close
+      @db.close
+    end
+
+    def schema_version
+      @db.get_first_value("PRAGMA user_version")
+    end
+
+    private
+
+    def get_task_raw(task_id)
+      @db.get_first_row("SELECT * FROM tasks WHERE id = ?", [task_id])
+    end
+
+    def current_user
+      ENV["USER"] || ENV["USERNAME"] || "unspecified"
+    end
+
+    def record_history(task_id, actor, action, detail)
+      now = Time.now.utc.iso8601
+      @db.execute(
+        "INSERT INTO task_history (task_id, actor, action, detail, created_at) VALUES (?, ?, ?, ?, ?)",
+        [task_id, actor, action, detail, now]
+      )
+    end
+
+    MIGRATIONS = [
+      # Version 1: Initial schema
+      <<~SQL
+        CREATE TABLE tasks (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          title TEXT NOT NULL,
+          description TEXT,
+          board TEXT NOT NULL DEFAULT 'backlog',
+          author TEXT NOT NULL,
+          assignee TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE comments (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task_id INTEGER NOT NULL,
+          author TEXT NOT NULL,
+          text TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          FOREIGN KEY (task_id) REFERENCES tasks(id)
+        );
+
+        CREATE TABLE task_history (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task_id INTEGER NOT NULL,
+          actor TEXT NOT NULL,
+          action TEXT NOT NULL,
+          detail TEXT,
+          created_at TEXT NOT NULL,
+          FOREIGN KEY (task_id) REFERENCES tasks(id)
+        );
+
+        CREATE TABLE task_dependencies (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task_id INTEGER NOT NULL,
+          depends_on_id INTEGER NOT NULL,
+          dependency_type TEXT NOT NULL,
+          FOREIGN KEY (task_id) REFERENCES tasks(id),
+          FOREIGN KEY (depends_on_id) REFERENCES tasks(id),
+          UNIQUE(task_id, depends_on_id, dependency_type)
+        );
+
+        CREATE INDEX idx_tasks_board ON tasks(board);
+        CREATE INDEX idx_comments_task_id ON comments(task_id);
+        CREATE INDEX idx_task_history_task_id ON task_history(task_id);
+        CREATE INDEX idx_task_dependencies_task_id ON task_dependencies(task_id);
+        CREATE INDEX idx_task_dependencies_depends_on ON task_dependencies(depends_on_id);
+      SQL
+      # To add a new migration:
+      # 1. Append a new SQL string to this array
+      # 2. It will run automatically on databases that haven't applied it yet
+      # 3. Never modify existing migrations -- always add new ones
+    ].freeze
+
+    def migrate!
+      current = schema_version
+
+      MIGRATIONS.each_with_index do |sql, index|
+        version = index + 1
+        next if version <= current
+
+        @db.transaction do
+          @db.execute_batch(sql)
+          @db.execute("PRAGMA user_version = #{version}")
+        end
+      end
+    end
+  end
+end