rubydb 0.1.0

data/lib/rubydb/cli/commands/checkout.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Checkout - Switch to a branch
+      class Checkout
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb checkout [options]"
+            opts.on("-b", "--create NAME", "Create and checkout branch") do |name|
+              options[:create] = name
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--branch-dir DIR", "Branch metadata directory") { |path| options[:branch_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          branch = args.first
+          if branch.nil? && options[:create].nil?
+            @output.error("Branch name required")
+            @output.puts parser
+            return
+          end
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          manager = RubyDB::Branching::BranchManager.new(
+            database.engine,
+            branch_dir: options[:branch_dir] || "branches"
+          )
+          selected = options[:create] || branch
+          result = manager.create_branch(selected, from: manager.current_branch_name) if options[:create]
+          raise result[:error] if result && !result[:success]
+          result = manager.checkout(selected)
+          raise result[:error] unless result[:success]
+          @output.success("Switched to branch #{selected}")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/create.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Create - Create a database
+      class Create
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb create [options]"
+            opts.on("-n", "--name NAME", "Database name") do |name|
+              options[:name] = name
+            end
+            opts.on("-d", "--dir DIR", "Data directory") do |dir|
+              options[:dir] = dir
+            end
+            opts.on("-f", "--force", "Force create") do
+              options[:force] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          name = options[:name] || "rubydb"
+          dir = options[:dir] || "data"
+          db_path = options[:database] || File.join(dir, "#{name}.rdb")
+          if File.exist?(db_path) && !options[:force]
+            @output.error("Database already exists at #{db_path}. Use --force to recreate it.")
+            return 1
+          end
+
+          @output.spinner("Creating database #{name}...") do
+            FileUtils.mkdir_p(File.dirname(db_path))
+            if options[:force]
+              [db_path, "#{db_path}.metadata", "#{db_path}.visibility", "#{db_path}.mvcc", "#{db_path}.wal"].each do |path|
+                FileUtils.rm_rf(path) if File.exist?(path)
+              end
+            end
+            engine = RubyDB::Storage::Engine.new(db_path, auto_vacuum: false)
+            engine.close
+            @output.success("Database #{name} created at #{db_path}")
+          end
+          0
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/diff.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Diff - Show differences between branches
+      class Diff
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb diff [options]"
+            opts.on("--table TABLE", "Only show differences for a table") do |table|
+              options[:table] = table
+            end
+          opts.on("--summary", "Show summary only") do
+            options[:summary] = true
+          end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--branch-dir DIR", "Branch metadata directory") { |path| options[:branch_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          branch_a = args[0] || "main"
+          branch_b = args[1] || "current"
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          manager = RubyDB::Branching::BranchManager.new(
+            database.engine,
+            branch_dir: options[:branch_dir] || "branches"
+          )
+          branch_b = manager.current_branch_name || "main" if branch_b == "current"
+          result = RubyDB::Branching::Diff.new(database.engine, manager).diff(
+            branch_a, branch_b, type: RubyDB::Branching::Diff::DIFF_ALL,
+            tables: (options[:table] && [options[:table]])
+          )
+          raise result[:error] unless result[:success]
+
+          changes = result[:changes]
+          diff_data = {
+            added_tables: [], removed_tables: [], changed_tables: [],
+            added_columns: [], removed_columns: [], changed_columns: [],
+            changes: changes
+          }
+
+          if options[:summary]
+            @output.puts "Differences between #{branch_a} and #{branch_b}:"
+            @output.puts "  Added tables: #{diff_data[:added_tables].size}"
+            @output.puts "  Removed tables: #{diff_data[:removed_tables].size}"
+            @output.puts "  Changed tables: #{diff_data[:changed_tables].size}"
+            @output.puts "  Added columns: #{diff_data[:added_columns].size}"
+            @output.puts "  Removed columns: #{diff_data[:removed_columns].size}"
+            @output.puts "  Changed columns: #{diff_data[:changed_columns].size}"
+          else
+            @output.puts "Differences between #{branch_a} and #{branch_b}:"
+            @output.puts "  Added changes: #{changes[:added].size}"
+            @output.puts "  Removed changes: #{changes[:removed].size}"
+            changes.each do |kind, entries|
+              entries.each { |entry| @output.puts "  #{kind}: #{entry.inspect}" }
+            end
+          end
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/doctor.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Doctor - Run health checks
+      class Doctor
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb doctor [options]"
+            opts.on("--fix", "Attempt to fix issues") do
+              options[:fix] = true
+            end
+            opts.on("--quick", "Quick check only") do
+              options[:quick] = true
+            end
+            opts.on("--json", "Output as JSON") do
+              options[:json] = true
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          config = RubyDB::Configuration::Config.instance
+          db_path = config.get("storage.data_dir") || "data/rubydb.rdb"
+          checks = []
+          engine = nil
+
+          begin
+            started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            engine = RubyDB::Storage::Engine.new(db_path, auto_vacuum: false)
+            latency_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+            checks << { name: "Connection", passed: true, details: { database: db_path, latency_ms: latency_ms } }
+            checks << { name: "Storage", passed: engine.storage_manager.open?, details: engine.storage_manager.stats }
+            checks << { name: "WAL", passed: !engine.wal.nil?, details: engine.wal.stats }
+            unless options[:quick]
+              checks << { name: "Indexes", passed: !engine.index_manager.nil?, details: engine.index_manager.stats }
+            end
+          rescue => e
+            checks << { name: "Connection", passed: false, errors: [e.message] }
+          ensure
+            engine&.close if engine&.open?
+          end
+
+          results = {
+            passed: checks.all? { |check| check[:passed] },
+            total_count: checks.size,
+            passed_count: checks.count { |check| check[:passed] },
+            checks: checks
+          }
+
+          if options[:json]
+            @output.json(results)
+          else
+            @formatter.format_doctor(results)
+
+            if options[:fix] && !results[:passed]
+              @output.puts "\nAutomatic repair is not available for the reported checks; no changes were made.", :yellow
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/drop.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Drop - Drop a database
+      class Drop
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb drop [options]"
+            opts.on("-n", "--name NAME", "Database name") do |name|
+              options[:name] = name
+            end
+            opts.on("-f", "--force", "Force drop") do
+              options[:force] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--dir DIR", "Database data directory") { |dir| options[:dir] = dir }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          name = options[:name] || "rubydb"
+          db_path = options[:database] || File.join(options[:dir] || "data", "#{name}.rdb")
+          unless File.file?(db_path)
+            @output.error("Database not found at #{db_path}")
+            return 1
+          end
+
+          unless options[:force]
+            @output.warn("This will permanently delete database '#{name}'")
+            @output.print("Are you sure? (yes/no): ", nil, false)
+            response = $stdin.gets.chomp
+            return unless response.downcase == "yes"
+          end
+
+          @output.spinner("Dropping database #{name}...") do
+            [db_path, "#{db_path}.metadata", "#{db_path}.visibility", "#{db_path}.mvcc", "#{db_path}.wal"].each do |path|
+              FileUtils.rm_rf(path) if File.exist?(path)
+            end
+            @output.success("Database #{name} dropped")
+          end
+          0
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/init.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RubyDB
+  module CLI
+    module Commands
+      class Init
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb init [options]"
+            opts.on("-n", "--name NAME", "Database name") do |name|
+              options[:name] = name
+            end
+            opts.on("-d", "--dir DIR", "Data directory") do |dir|
+              options[:dir] = dir
+            end
+            opts.on("-f", "--force", "Force overwrite") do
+              options[:force] = true
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          name = options[:name] || "rubydb"
+          dir = options[:dir] || "data"
+          db_path = File.join(dir, "#{name}.rdb")
+
+          if File.exist?(db_path) && !options[:force]
+            @output.error("Database already exists at #{db_path}. Use --force to overwrite.")
+            return 1
+          end
+
+          @output.spinner("Initializing database #{name}...") do
+            # Create directory
+            FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+            # Initialize storage engine
+            engine = RubyDB::Storage::Engine.new(db_path, {})
+            
+            # Create default tables
+            create_default_tables(engine)
+            
+            # Create default user if not exists
+            create_default_user(engine) if options[:user]
+
+            @output.success("Database #{name} initialized at #{db_path}")
+          end
+
+          0
+        end
+
+        private
+
+        def create_default_tables(engine)
+          # Create schema_migrations table
+          engine.create_table("schema_migrations") do |t|
+            t.column("version", :text, primary_key: true)
+            t.column("applied_at", :timestamp)
+          end
+
+          # Create users table
+          engine.create_table("users") do |t|
+            t.column("id", :integer, primary_key: true, auto_increment: true)
+            t.column("username", :text, unique: true, null: false)
+            t.column("email", :text, unique: true)
+            t.column("password_hash", :text)
+            t.column("salt", :text)
+            t.column("created_at", :timestamp)
+            t.column("updated_at", :timestamp)
+          end
+
+          # Create sessions table
+          engine.create_table("sessions") do |t|
+            t.column("id", :integer, primary_key: true, auto_increment: true)
+            t.column("user_id", :integer)
+            t.column("token", :text, unique: true)
+            t.column("created_at", :timestamp)
+            t.column("expires_at", :timestamp)
+          end
+        end
+
+        def create_default_user(engine)
+          # Create admin user
+          engine.insert_row("users", 
+            ["username", "email", "created_at"], 
+            ["admin", "admin@localhost", Time.now]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/inspect.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Inspect - Inspect database internals
+      class Inspect
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb inspect [options]"
+            opts.on("-t", "--table TABLE", "Inspect specific table") do |table|
+              options[:table] = table
+            end
+            opts.on("--pages", "Show page information") do
+              options[:pages] = true
+            end
+            opts.on("--indexes", "Show index information") do
+              options[:indexes] = true
+            end
+            opts.on("--stats", "Show statistics") do
+              options[:stats] = true
+            end
+            opts.on("--wal", "Show WAL information") do
+              options[:wal] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          engine = database.engine
+          stats = engine.stats
+
+          if options[:table]
+            table = options[:table]
+            raise "Table '#{table}' does not exist" unless engine.table_exists?(table)
+            columns = engine.table_columns(table)
+            @output.heading("Table: #{table}", 2)
+            @output.puts "Columns:"
+            columns.each { |column| @output.puts "  #{column.name}: #{column.type_class}" }
+            @output.puts "\nRows: #{engine.select_rows(table, columns).size}"
+          end
+
+          if options[:pages]
+            @output.heading("Pages", 2)
+            @output.puts "Total pages: #{stats[:page_count]}"
+            @output.puts "Used pages: #{stats[:used_pages]}"
+            @output.puts "Free pages: #{stats[:free_pages]}"
+          end
+
+          if options[:indexes]
+            @output.heading("Indexes", 2)
+            @output.puts "Index statistics: #{engine.index_manager.stats.inspect}"
+          end
+
+          if options[:stats]
+            @output.heading("Statistics", 2)
+            stats.each { |key, value| @output.puts "#{key}: #{value}" }
+          end
+
+          if options[:wal]
+            @output.heading("WAL Information", 2)
+            wal_files = engine.wal_files
+            wal_size = wal_files.sum { |file| File.size(file) }
+            @output.puts "WAL enabled: #{!wal_files.empty?}"
+            @output.puts "WAL files: #{wal_files.size}"
+            @output.puts "WAL size: #{wal_size} bytes"
+          end
+
+          if !options[:table] && !options[:pages] && !options[:indexes] && !options[:stats] && !options[:wal]
+            @output.heading("Database Inspection", 1)
+            @output.puts "Version: #{RubyDB::VERSION}"
+            @output.puts "Tables: #{stats[:table_count]}"
+            @output.puts "Total pages: #{stats[:page_count]}"
+            @output.puts "Database size: #{File.size(engine.path)} bytes"
+            @output.puts "Cache hit rate: #{stats[:cache_hit_rate]}"
+          end
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/merge.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Merge - Merge a branch
+      class Merge
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb merge [options]"
+            opts.on("--into BRANCH", "Target branch") do |branch|
+              options[:into] = branch
+            end
+            opts.on("--strategy STRATEGY", "Merge strategy (fast-forward, recursive)") do |strategy|
+              options[:strategy] = strategy.to_sym
+            end
+            opts.on("--no-commit", "Don't commit after merge") do
+              options[:no_commit] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--branch-dir DIR", "Branch metadata directory") { |path| options[:branch_dir] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          source = args.first
+          if source.nil?
+            @output.error("Source branch required")
+            @output.puts parser
+            return
+          end
+
+          target = options[:into] || "main"
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          manager = RubyDB::Branching::BranchManager.new(
+            database.engine,
+            branch_dir: options[:branch_dir] || "branches"
+          )
+          merger = RubyDB::Branching::Merge.new(database.engine, manager,
+                                                strategy: (options[:strategy] || :fast_forward))
+          result = nil
+          @output.spinner("Merging #{source} into #{target}...") do
+            result = merger.merge(source, target, abort_on_conflict: true)
+          end
+          raise result[:error] || result[:message] unless result[:success]
+          @output.success(result[:message] || "Merge completed successfully")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/migrate.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Migrate - Run database migrations
+      class Migrate
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb migrate [options]"
+            opts.on("-v", "--version VERSION", "Migrate to version") do |version|
+              options[:version] = version
+            end
+            opts.on("-s", "--steps N", Integer, "Rollback N steps") do |steps|
+              options[:steps] = steps
+            end
+            opts.on("--down", "Migrate down") do
+              options[:down] = true
+            end
+            opts.on("--dry-run", "Show what would be run") do
+              options[:dry_run] = true
+            end
+            opts.on("--database PATH", "Database path") { |path| options[:database] = path }
+            opts.on("--path DIR", "Migration directory") { |path| options[:migrations_path] = path }
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          end
+
+          parser.parse!(args)
+
+          database = RubyDB::Database.new(options[:database] || "data/rubydb.rdb", auto_connect: false).connect
+          manager = RubyDB::Migrations::MigrationManager.new(
+            database,
+            path: options[:migrations_path] || "db/migrate",
+            version: options[:version]
+          )
+          if options[:dry_run]
+            @formatter.format_migrations(manager.status)
+          elsif options[:down]
+            manager.rollback(options[:steps] || 1)
+            @output.success("Migration rollback completed")
+          else
+            manager.migrate
+            @output.success("Migrations completed successfully")
+          end
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/commands/restart.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Sends a restart signal to the process recorded by the PID file.
+      class Restart
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb restart [options]"
+            opts.on("--pid-file FILE", "PID file") { |file| options[:pid_file] = file }
+            opts.on("--force", "Send KILL instead of TERM") { options[:force] = true }
+            opts.on("-h", "--help", "Show help") { @output.puts opts; return 0 }
+          end
+          parser.parse!(args)
+
+          pid_file = options[:pid_file] || "rubydb.pid"
+          raise "PID file not found: #{pid_file}" unless File.file?(pid_file)
+          pid = Integer(File.read(pid_file).strip, 10)
+          Process.kill(0, pid)
+          Process.kill(options[:force] ? "KILL" : "TERM", pid)
+          @output.success("RubyDB restart signal sent to PID #{pid}")
+          0
+        rescue Errno::ESRCH
+          raise "RubyDB process #{pid} is not running"
+        rescue ArgumentError
+          raise "Invalid PID in #{pid_file}"
+        end
+      end
+    end
+  end
+end