rubydb 0.1.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      class Status
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb status [options]"
+            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)
+
+          # Get real status from engine
+          config = RubyDB::Configuration::Config.instance
+          db_path = config.get("storage.data_dir") || "data/rubydb.rdb"
+
+          status_data = {
+            database: File.basename(db_path, ".rdb"),
+            mode: "server",
+            status: "unavailable",
+            version: RubyDB::VERSION,
+            pid: Process.pid,
+            uptime: Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i,
+            connections: 0,
+            tables: 0,
+            storage_size: File.exist?(db_path) ? File.size(db_path) : 0,
+            memory_usage: get_memory_usage,
+            wal_enabled: true,
+            replication: { role: "unknown", status: "not_configured", lag_ms: nil },
+            branch: { current: "unknown", total: nil }
+          }
+
+          engine = nil
+          begin
+            engine = RubyDB::Storage::Engine.new(db_path, {})
+            status_data[:status] = "running"
+            status_data[:tables] = engine.list_tables.size
+            status_data[:connections] = engine.connection_count rescue 0
+            status_data[:wal_enabled] = !engine.wal.nil?
+          rescue => error
+            status_data[:error] = error.message
+          ensure
+            engine&.close if engine&.open?
+          end
+
+          if options[:json]
+            @output.json(status_data)
+          else
+            @formatter.format_status(status_data)
+          end
+
+          0
+        end
+
+        private
+
+        def get_memory_usage
+          if File.exist?("/proc/self/status")
+            File.read("/proc/self/status").each_line do |line|
+              if line.start_with?("VmRSS:")
+                return line.split[1].to_i * 1024
+              end
+            end
+          end
+
+          # Fallback - run ps command
+          begin
+            output = `ps -o rss= -p #{Process.pid}`
+            return output.strip.to_i * 1024 if output && !output.empty?
+          rescue
+            # Ignore
+          end
+
+          0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyDB
+  module CLI
+    module Commands
+      # Stop - Stop the database server
+      class Stop
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb stop [options]"
+            opts.on("-f", "--force", "Force stop") do
+              options[:force] = true
+            end
+            opts.on("--pid-file FILE", "PID file") do |file|
+              options[:pid_file] = file
+            end
+            opts.on("-h", "--help", "Show help") do
+              @output.puts opts
+              exit(0)
+            end
+          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 server stop 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

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    module Commands
+      # Vacuum - Vacuum the database
+      class Vacuum
+        def initialize(output, formatter)
+          @output = output
+          @formatter = formatter
+        end
+
+        def execute(args, options)
+          parser = OptionParser.new do |opts|
+            opts.banner = "Usage: rubydb vacuum [options]"
+            opts.on("--full", "Full vacuum (reclaim space)") do
+              options[:full] = true
+            end
+            opts.on("--analyze", "Analyze after vacuum") do
+              options[:analyze] = true
+            end
+            opts.on("--table TABLE", "Vacuum specific table") do |table|
+              options[:table] = table
+            end
+            opts.on("--dry-run", "Show what would be vacuumed") do
+              options[:dry_run] = 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
+
+          if options[:dry_run]
+            @output.info("Would vacuum:")
+            stats = engine.stats
+            @output.puts("  - Current rows: #{stats[:row_count]}")
+            @output.puts("  - Tables affected: #{stats[:table_count]}")
+            @output.puts("  - Cleanup will respect active transaction snapshots")
+            return 0
+          end
+
+          result = engine.vacuum
+          @output.success("Vacuum completed. Removed #{result[:removed]} rows; #{result[:total_rows]} rows remain.")
+          0
+        ensure
+          database&.close
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/cli/formatter.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module CLI
+    # Formatter - Formats CLI output
+    class Formatter
+      def initialize(output)
+        @output = output
+      end
+
+      def format_status(status_data)
+        @output.heading("RubyDB Status", 1)
+
+        @output.puts "Database: #{status_data[:database] || 'N/A'}"
+        @output.puts "Mode: #{status_data[:mode] || 'N/A'}"
+        @output.puts "Status: #{status_data[:status] || 'N/A'}"
+        @output.puts "Version: #{status_data[:version] || RubyDB::VERSION}"
+        @output.puts "PID: #{status_data[:pid] || 'N/A'}"
+        @output.puts "Uptime: #{format_uptime(status_data[:uptime])}"
+        @output.puts "Connections: #{status_data[:connections] || 0}"
+        @output.puts "Tables: #{status_data[:tables] || 0}"
+        @output.puts "Storage: #{format_size(status_data[:storage_size])}"
+        @output.puts "Memory: #{format_size(status_data[:memory_usage])}"
+        @output.puts "WAL: #{status_data[:wal_enabled] ? 'Enabled' : 'Disabled'}"
+
+        if status_data[:replication]
+          @output.puts "\nReplication:"
+          @output.puts "  Role: #{status_data[:replication][:role]}"
+          @output.puts "  Status: #{status_data[:replication][:status]}"
+          @output.puts "  Lag: #{status_data[:replication][:lag_ms]}ms"
+        end
+
+        if status_data[:branch]
+          @output.puts "\nBranch:"
+          @output.puts "  Current: #{status_data[:branch][:current]}"
+          @output.puts "  Total: #{status_data[:branch][:total]}"
+        end
+      end
+
+      def format_backups(backups)
+        return @output.puts("No backups found", :yellow) if backups.empty?
+
+        headers = ["Name", "Type", "Size", "Created At", "Age"]
+        rows = backups.map do |b|
+          [
+            b[:name],
+            b[:type],
+            format_size(b[:size]),
+            b[:created_at],
+            format_age(b[:age])
+          ]
+        end
+
+        @output.table(headers, rows, show_count: true)
+      end
+
+      def format_branches(branches)
+        return @output.puts("No branches found", :yellow) if branches.empty?
+
+        headers = ["Name", "State", "Commits", "Created At", "Parent"]
+        rows = branches.map do |b|
+          [
+            b[:name],
+            b[:state],
+            b[:commit_count],
+            b[:created_at],
+            b[:parent_branch] || "-"
+          ]
+        end
+
+        @output.table(headers, rows, show_count: true)
+      end
+
+      def format_tables(tables)
+        return @output.puts("No tables found", :yellow) if tables.empty?
+
+        headers = ["Table", "Rows", "Columns", "Size", "Created At"]
+        rows = tables.map do |t|
+          [
+            t[:name],
+            t[:row_count],
+            t[:column_count],
+            format_size(t[:size]),
+            t[:created_at]
+          ]
+        end
+
+        @output.table(headers, rows, show_count: true)
+      end
+
+      def format_migrations(migrations)
+        return @output.puts("No migrations found", :yellow) if migrations.empty?
+
+        migrations = migrations.map do |migration|
+          migration.merge(applied: migration[:applied] || migration[:state]&.to_sym == :applied)
+        end
+
+        headers = ["Version", "Name", "Status", "Applied At"]
+        rows = migrations.map do |m|
+          [
+            m[:version],
+            m[:name],
+            m[:applied] ? "✓ Applied" : "⏳ Pending",
+            m[:applied_at] || "-"
+          ]
+        end
+
+        @output.table(headers, rows, show_count: true)
+      end
+
+      def format_diff(diff_data)
+        @output.heading("Database Diff", 2)
+
+        if diff_data[:added_tables].any?
+          @output.puts "Added Tables:", :green
+          diff_data[:added_tables].each { |t| @output.puts "  + #{t}" }
+        end
+
+        if diff_data[:removed_tables].any?
+          @output.puts "\nRemoved Tables:", :red
+          diff_data[:removed_tables].each { |t| @output.puts "  - #{t}" }
+        end
+
+        if diff_data[:changed_tables].any?
+          @output.puts "\nChanged Tables:", :yellow
+          diff_data[:changed_tables].each do |t|
+            @output.puts "  ~ #{t[:name]}"
+            t[:changes].each do |change|
+              @output.puts "    - #{change}"
+            end
+          end
+        end
+
+        if diff_data[:added_columns].any?
+          @output.puts "\nAdded Columns:", :green
+          diff_data[:added_columns].each do |c|
+            @output.puts "  + #{c[:table]}.#{c[:column]} (#{c[:type]})"
+          end
+        end
+
+        if diff_data[:removed_columns].any?
+          @output.puts "\nRemoved Columns:", :red
+          diff_data[:removed_columns].each do |c|
+            @output.puts "  - #{c[:table]}.#{c[:column]}"
+          end
+        end
+
+        if diff_data[:changed_columns].any?
+          @output.puts "\nChanged Columns:", :yellow
+          diff_data[:changed_columns].each do |c|
+            @output.puts "  ~ #{c[:table]}.#{c[:column]} (#{c[:old_type]} → #{c[:new_type]})"
+          end
+        end
+
+        if diff_data[:added_tables].empty? && diff_data[:removed_tables].empty? &&
+           diff_data[:changed_tables].empty? && diff_data[:added_columns].empty? &&
+           diff_data[:removed_columns].empty? && diff_data[:changed_columns].empty?
+          @output.puts "No differences found", :green
+        end
+      end
+
+      def format_doctor(results)
+        @output.heading("Database Health Check", 1)
+
+        results[:checks].each do |check|
+          status = check[:passed] ? "✓" : "✗"
+          color = check[:passed] ? :green : :red
+          @output.puts "#{status} #{check[:name]}", color
+
+          if check[:details]
+            @output.puts "  Details:", :gray
+            check[:details].each do |key, value|
+              @output.puts "    #{key}: #{value}", :gray
+            end
+          end
+
+          if check[:errors] && check[:errors].any?
+            @output.puts "  Errors:", :red
+            check[:errors].each { |e| @output.puts "    - #{e}", :red }
+          end
+        end
+
+        @output.puts "\nOverall: #{results[:passed] ? 'Healthy' : 'Issues Found'}", results[:passed] ? :green : :red
+        @output.puts "Checks Passed: #{results[:passed_count]}/#{results[:total_count]}"
+      end
+
+      private
+
+      def format_size(bytes)
+        return "0 B" if bytes.to_i == 0
+        units = ["B", "KB", "MB", "GB", "TB"]
+        exp = (Math.log(bytes) / Math.log(1024)).floor
+        size = bytes / (1024.0 ** exp)
+        "#{size.round(2)} #{units[exp]}"
+      end
+
+      def format_age(seconds)
+        return "N/A" unless seconds
+        return "#{seconds.round}s" if seconds < 60
+        return "#{(seconds / 60).round}m" if seconds < 3600
+        return "#{(seconds / 3600).round}h" if seconds < 86400
+        "#{(seconds / 86400).round}d"
+      end
+
+      def format_uptime(seconds)
+        return "N/A" unless seconds
+        days = (seconds / 86400).to_i
+        hours = ((seconds % 86400) / 3600).to_i
+        minutes = ((seconds % 3600) / 60).to_i
+
+        parts = []
+        parts << "#{days}d" if days > 0
+        parts << "#{hours}h" if hours > 0 || days > 0
+        parts << "#{minutes}m"
+        parts.join(" ")
+      end
+    end
+  end
+end

data/lib/rubydb/cli/output.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module CLI
+    # Output - Handles CLI output formatting
+    class Output
+      COLORS = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        red: "\e[31m",
+        green: "\e[32m",
+        yellow: "\e[33m",
+        blue: "\e[34m",
+        magenta: "\e[35m",
+        cyan: "\e[36m",
+        white: "\e[37m",
+        gray: "\e[90m",
+        bright_red: "\e[91m",
+        bright_green: "\e[92m",
+        bright_yellow: "\e[93m",
+        bright_blue: "\e[94m"
+      }
+
+      def initialize(no_color: false, quiet: false, format: :text)
+        @no_color = no_color
+        @quiet = quiet
+        @format = format
+        @buffer = []
+      end
+
+      def print(message, color = nil, newline = true)
+        return if @quiet
+
+        if color && !@no_color
+          message = "#{COLORS[color]}#{message}#{COLORS[:reset]}"
+        end
+
+        $stdout.print(message)
+        $stdout.print("\n") if newline
+      end
+
+      def puts(message = "", color = nil)
+        print(message, color, true)
+      end
+
+      def error(message)
+        print("Error: #{message}", :bright_red)
+      end
+
+      def warn(message)
+        print("Warning: #{message}", :yellow)
+      end
+
+      def success(message)
+        print("✓ #{message}", :green)
+      end
+
+      def info(message)
+        print("ℹ #{message}", :blue)
+      end
+
+      def debug(message)
+        print("DEBUG: #{message}", :gray) if ENV["RUBYDB_DEBUG"]
+      end
+
+      def table(headers, rows, options = {})
+        return if rows.empty? && !options[:show_empty]
+
+        # Calculate column widths
+        widths = headers.map.with_index do |h, i|
+          max = h.to_s.length
+          rows.each do |row|
+            val = row[i].to_s
+            max = val.length if val.length > max
+          end
+          max
+        end
+
+        # Print headers
+        header_line = headers.each_with_index.map { |h, i| h.to_s.ljust(widths[i]) }.join("  ")
+        puts header_line, :bold
+        puts "-" * header_line.length, :gray
+
+        # Print rows
+        rows.each do |row|
+          line = row.each_with_index.map { |val, i| val.to_s.ljust(widths[i]) }.join("  ")
+          puts line
+        end
+
+        puts "\nTotal: #{rows.size}" if options[:show_count]
+      end
+
+      def json(data)
+        require "json"
+        puts JSON.pretty_generate(data)
+      end
+
+      def yaml(data)
+        require "yaml"
+        puts data.to_yaml
+      end
+
+      def progress(current, total, message = nil)
+        percent = (current.to_f / total * 100).round(1)
+        bar_length = 40
+        filled = (percent / 100 * bar_length).round
+        bar = "[" + "=" * filled + " " * (bar_length - filled) + "]"
+
+        if message
+          print("\r#{message} #{bar} #{percent}%", nil, false)
+        else
+          print("\r#{bar} #{percent}%", nil, false)
+        end
+
+        print("\n") if current == total
+      end
+
+      def spinner(message = nil)
+        return unless block_given?
+
+        chars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        index = 0
+        thread = Thread.new do
+          while true
+            print("\r#{chars[index % chars.length]} #{message}", nil, false)
+            index += 1
+            sleep(0.1)
+          end
+        end
+
+        result = yield
+        thread.kill
+        print("\r✓ #{message}", :green)
+        puts
+        result
+      end
+
+      def heading(text, level = 1)
+        case level
+        when 1
+          puts "#{'=' * text.length}", :bold
+          puts text, :bold
+          puts "#{'=' * text.length}", :bold
+        when 2
+          puts text, :bold
+          puts "-" * text.length, :gray
+        else
+          puts text, :bold
+        end
+        puts
+      end
+
+      def write(data)
+        @buffer << data
+      end
+
+      def flush
+        result = @buffer.join("\n")
+        @buffer.clear
+        result
+      end
+
+      def quiet?
+        @quiet
+      end
+    end
+  end
+end