smart_box 0.1.1

data/lib/smart_box/cli.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require_relative "../smart_box"
+require "optparse"
+
+module SmartBox
+  module CLI
+    def self.run(argv = ARGV)
+      parse_options(argv)
+      command = argv.first
+
+      case command
+      when "--version", "-v"
+        puts "smart_box #{SmartBox::VERSION}"
+      when "--help", "-h", nil
+        print_help
+      when "create"
+        cmd_create(argv)
+      when "list"
+        cmd_list(argv)
+      when "status"
+        cmd_status(argv)
+      when "run"
+        cmd_run(argv)
+      when "checkpoint"
+        cmd_checkpoint(argv)
+      when "checkpoints"
+        cmd_checkpoints(argv)
+      when "rollback"
+        cmd_rollback(argv)
+      when "diff"
+        cmd_diff(argv)
+      when "export-patch"
+        cmd_export_patch(argv)
+      when "apply"
+        cmd_apply(argv)
+      when "discard"
+        cmd_discard(argv)
+      else
+        puts "Unknown command: #{command}"
+        print_help
+        exit 1
+      end
+    rescue SmartBox::Error => e
+      $stderr.puts "Error: #{e.message}"
+      exit 2
+    end
+
+    # --- Command implementations ---
+
+    def self.cmd_create(argv)
+      opts = parse_create(argv)
+      source = opts[:source] || "."
+      id     = opts[:id]
+      mode   = opts[:mode] || "copy"
+      name   = opts[:name]
+
+      unless id
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      unless %w[copy git-worktree].include?(mode)
+        $stderr.puts "Error: --mode must be 'copy' or 'git-worktree'"
+        exit 1
+      end
+
+      box = SmartBox::Box.create(source: source, id: id, mode: mode, name: name)
+
+      puts "Box created:"
+      puts "  id: #{box.id}"
+      puts "  mode: #{box.mode}"
+      puts "  workspace: #{box.workspace_path}"
+      puts "  checkpoint: cp-001 initial"
+    end
+
+    def self.cmd_list(argv)
+      opts = parse_source(argv)
+      source = opts[:source] || "."
+
+      boxes = SmartBox::Box.list(source: source)
+
+      if boxes.empty?
+        puts "No boxes found."
+        return
+      end
+
+      puts "ID          MODE          STATUS    UPDATED_AT"
+      boxes.each do |b|
+        updated = b["updated_at"]
+        updated = updated[0..15] if updated.is_a?(String) && updated.length > 16
+        printf "%-10s  %-12s  %-8s  %s\n",
+          b["id"], b["mode"], b["status"], updated
+      end
+    end
+
+    def self.cmd_status(argv)
+      opts = parse_box_opts(argv, require_id: true)
+      box  = SmartBox::Box.load(source: opts[:source] || ".", id: opts[:id])
+      s    = box.status_summary
+
+      puts "Box: #{s['id']}"
+      puts "Mode: #{s['mode']}"
+      puts "Status: #{s['status']}"
+      puts "Workspace: #{s['workspace']}"
+      puts
+
+      if s["changed_files"]&.any?
+        puts "Changed files:"
+        s["changed_files"].each { |f| puts "  #{f}" }
+      else
+        puts "No changed files."
+      end
+      puts
+
+      if s["checkpoints"]&.any?
+        puts "Checkpoints:"
+        s["checkpoints"].each do |cp|
+          cp.each { |id, name| puts "  #{id} #{name}" }
+        end
+      end
+    end
+
+    def self.cmd_run(argv)
+      argv.shift  # remove "run" subcommand name
+      opts = parse_run(argv)
+      id = opts[:id]
+
+      unless id
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      command = argv.join(" ")
+      if command.empty?
+        $stderr.puts "Error: command is required (use -- before command args)"
+        exit 1
+      end
+
+      box = SmartBox::Box.load(source: opts[:source] || ".", id: id)
+      result = box.run(command, allow_dangerous: opts[:allow_dangerous])
+
+      $stdout.write(result.stdout)
+      $stderr.write(result.stderr) unless result.stderr.empty?
+      exit result.exit_code
+    end
+
+    def self.cmd_checkpoint(argv)
+      opts = parse_checkpoint(argv)
+      id   = opts[:id]
+      name = opts[:name]
+
+      unless id
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      unless name
+        $stderr.puts "Error: --name is required"
+        exit 1
+      end
+
+      box  = SmartBox::Box.load(source: opts[:source] || ".", id: id)
+      cp   = box.checkpoint(name)
+
+      puts "Checkpoint created:"
+      puts "  id: #{cp[:id]}"
+      puts "  name: #{cp[:name]}"
+      puts "  commit: #{cp[:commit][0..7]}"
+    end
+
+    def self.cmd_checkpoints(argv)
+      opts = parse_box_opts(argv, require_id: true)
+      box  = SmartBox::Box.load(source: opts[:source] || ".", id: opts[:id])
+      cps  = box.checkpoints
+
+      if cps.empty?
+        puts "No checkpoints."
+        return
+      end
+
+      cps.each do |cp|
+        puts "#{cp['id']}  #{cp['name']}"
+      end
+    end
+
+    def self.cmd_rollback(argv)
+      opts        = parse_rollback(argv)
+      id          = opts[:id]
+      checkpoint  = opts[:checkpoint]
+
+      unless id
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      unless checkpoint
+        $stderr.puts "Error: --checkpoint is required"
+        exit 1
+      end
+
+      box = SmartBox::Box.load(source: opts[:source] || ".", id: id)
+      box.rollback(checkpoint)
+
+      puts "Rolled back:"
+      puts "  box: #{id}"
+      puts "  checkpoint: #{checkpoint}"
+    end
+
+    def self.cmd_diff(argv)
+      opts = parse_diff(argv)
+      box  = SmartBox::Box.load(source: opts[:source] || ".", id: opts[:id])
+
+      unless box.metadata.id
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      puts box.diff(from: opts[:from], to: opts[:to])
+    end
+
+    def self.cmd_export_patch(argv)
+      opts = parse_export_patch(argv)
+
+      unless opts[:id]
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      unless opts[:output]
+        $stderr.puts "Error: --output is required"
+        exit 1
+      end
+
+      box = SmartBox::Box.load(source: opts[:source] || ".", id: opts[:id])
+      result = box.export_patch(output: opts[:output], from: opts[:from], to: opts[:to])
+
+      puts "Patch exported:"
+      puts "  #{result[:output]}"
+      puts "  #{result[:size]} bytes"
+    end
+
+    def self.cmd_apply(argv)
+      opts = parse_apply(argv)
+
+      unless opts[:id]
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+
+      box = SmartBox::Box.load(source: opts[:source] || ".", id: opts[:id])
+
+      if opts[:dry_run]
+        result = box.apply(dry_run: true)
+        puts "Dry run:"
+        puts "  patch size: #{result[:patch_size]} bytes"
+        puts "  Would apply #{result[:patch_size] > 0 ? 'changes' : 'no changes'} to #{box.source_path}"
+        return
+      end
+
+      # Check if source is clean before applying
+      unless opts[:force] || box.source_clean?
+        $stderr.puts "Error: Source project has uncommitted changes."
+        $stderr.puts "Use --force to apply anyway, or --dry-run to preview."
+        exit 1
+      end
+
+      result = box.apply(force: opts[:force])
+      puts "Patch applied:"
+      puts result
+    end
+
+    def self.cmd_discard(argv)
+      opts = parse_box_opts(argv, require_id: true)
+      box  = SmartBox::Box.load(source: opts[:source] || ".", id: opts[:id])
+      result = box.discard
+
+      puts "Box discarded:"
+      puts "  id: #{result[:id]}"
+      puts "  status: #{result[:status]}"
+    end
+
+    # --- Option parsers ---
+
+    def self.parse_create(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH")   { |v| opts[:source] = v }
+        p.on("--id ID")         { |v| opts[:id] = v }
+        p.on("--mode MODE")     { |v| opts[:mode] = v }
+        p.on("--name NAME")     { |v| opts[:name] = v }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_source(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH") { |v| opts[:source] = v }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_box_opts(argv, require_id: false)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH") { |v| opts[:source] = v }
+        p.on("--id ID")       { |v| opts[:id] = v }
+      end.parse!(argv)
+
+      if require_id && !opts[:id]
+        $stderr.puts "Error: --id is required"
+        exit 1
+      end
+      opts
+    end
+
+    def self.parse_run(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH")           { |v| opts[:source] = v }
+        p.on("--id ID")                 { |v| opts[:id] = v }
+        p.on("--allow-dangerous")       { |v| opts[:allow_dangerous] = true }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_checkpoint(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH") { |v| opts[:source] = v }
+        p.on("--id ID")       { |v| opts[:id] = v }
+        p.on("--name NAME")   { |v| opts[:name] = v }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_rollback(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH")     { |v| opts[:source] = v }
+        p.on("--id ID")           { |v| opts[:id] = v }
+        p.on("--checkpoint CP")   { |v| opts[:checkpoint] = v }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_diff(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH") { |v| opts[:source] = v }
+        p.on("--id ID")       { |v| opts[:id] = v }
+        p.on("--from CP")     { |v| opts[:from] = v }
+        p.on("--to CP")       { |v| opts[:to] = v }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_export_patch(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH") { |v| opts[:source] = v }
+        p.on("--id ID")       { |v| opts[:id] = v }
+        p.on("--output FILE") { |v| opts[:output] = v }
+        p.on("--from CP")     { |v| opts[:from] = v }
+        p.on("--to CP")       { |v| opts[:to] = v }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_apply(argv)
+      opts = {}
+      OptionParser.new do |p|
+        p.on("--source PATH") { |v| opts[:source] = v }
+        p.on("--id ID")       { |v| opts[:id] = v }
+        p.on("--dry-run")     { |v| opts[:dry_run] = true }
+        p.on("--force")       { |v| opts[:force] = true }
+      end.parse!(argv)
+      opts
+    end
+
+    def self.parse_options(argv)
+      # Global options stripped before command dispatch — handled in `run`
+    end
+
+    def self.print_help
+      puts <<~HELP
+        smart_box #{SmartBox::VERSION}
+
+        Usage:
+          smart_box <command> [options]
+
+        Commands:
+          create            Create a new box
+          list              List boxes
+          status            Show box status
+          run               Run a command in a box
+          checkpoint        Create a checkpoint
+          checkpoints       List checkpoints
+          rollback          Rollback to a checkpoint
+          diff              Show diff
+          export-patch      Export patch file
+          apply             Apply patch to source project
+          discard           Discard a box
+
+        Options:
+          --version, -v     Show version
+          --help, -h        Show this help
+      HELP
+    end
+  end
+end

data/lib/smart_box/command_result.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SmartBox
+  class CommandResult
+    attr_reader :command, :cwd, :stdout, :stderr, :exit_code, :started_at, :ended_at
+
+    def initialize(command:, cwd:, stdout:, stderr:, exit_code:, started_at:, ended_at:)
+      @command    = command
+      @cwd        = cwd
+      @stdout     = stdout
+      @stderr     = stderr
+      @exit_code  = exit_code
+      @started_at = started_at
+      @ended_at   = ended_at
+    end
+
+    def success?
+      @exit_code == 0
+    end
+
+    def elapsed_ms
+      ((@ended_at - @started_at) * 1000).to_i
+    end
+  end
+end

data/lib/smart_box/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SmartBox
+  class Error < StandardError; end
+
+  class BoxAlreadyExistsError < Error; end
+  class BoxNotFoundError < Error; end
+  class InvalidModeError < Error; end
+  class DirtySourceError < Error; end
+  class CheckpointNotFoundError < Error; end
+  class DangerousCommandError < Error; end
+  class PatchApplyError < Error; end
+end

data/lib/smart_box/metadata.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+
+module SmartBox
+  class Metadata
+    attr_reader :path, :data
+
+    def initialize(path)
+      @path = path
+      @data = {}
+    end
+
+    def load!
+      if File.exist?(@path)
+        @data = YAML.safe_load_file(@path, permitted_classes: [Time]) || {}
+      end
+      self
+    end
+
+    def save!
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir)
+      File.write(@path, YAML.dump(@data))
+      self
+    end
+
+    # --- Convenience accessors ---
+
+    def id
+      @data["id"]
+    end
+
+    def id=(val)
+      @data["id"] = val
+    end
+
+    def name
+      @data["name"]
+    end
+
+    def name=(val)
+      @data["name"] = val
+    end
+
+    def mode
+      @data["mode"]
+    end
+
+    def mode=(val)
+      @data["mode"] = val
+    end
+
+    def source_path
+      @data["source_path"]
+    end
+
+    def source_path=(val)
+      @data["source_path"] = val
+    end
+
+    def workspace_path
+      @data["workspace_path"]
+    end
+
+    def workspace_path=(val)
+      @data["workspace_path"] = val
+    end
+
+    def status
+      @data["status"] || "active"
+    end
+
+    def status=(val)
+      @data["status"] = val
+    end
+
+    def created_at
+      @data["created_at"]
+    end
+
+    def created_at=(val)
+      @data["created_at"] = val
+    end
+
+    def updated_at
+      @data["updated_at"] || Time.now.utc.iso8601
+    end
+
+    def updated_at=(val)
+      @data["updated_at"] = val
+    end
+
+    def base
+      @data["base"] ||= {}
+    end
+
+    def base=(val)
+      @data["base"] = val
+    end
+
+    def checkpoints
+      @data["checkpoints"] ||= []
+    end
+
+    def stats
+      @data["stats"] ||= {}
+    end
+
+    def stats=(val)
+      @data["stats"] = val
+    end
+
+    def add_checkpoint(id:, name:, git_commit:, created_at: Time.now.utc.iso8601)
+      checkpoints << {
+        "id"         => id,
+        "name"       => name,
+        "git_commit" => git_commit,
+        "created_at" => created_at
+      }
+    end
+  end
+end

data/lib/smart_box/modes/copy_mode.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "time"
+
+module SmartBox
+  module Modes
+    # copy mode: copies the source project into an isolated workspace directory,
+    # then initializes a git repo inside the workspace for checkpoint support.
+    class CopyMode
+      # Directories and files to exclude when copying the source project
+      COPY_EXCLUDES = %w[
+        .git
+        .smart_box
+        node_modules
+        vendor/bundle
+        .bundle
+        tmp
+        log
+      ].freeze
+
+      EXCLUDE_DIRS = %w[
+        .git
+        .smart_box
+        node_modules
+        tmp
+        log
+      ].freeze
+
+      attr_reader :source_path, :workspace_path
+
+      def initialize(source_path:, workspace_path:)
+        @source_path    = File.expand_path(source_path)
+        @workspace_path = File.expand_path(workspace_path)
+      end
+
+      # --- entry point ---
+
+      def setup
+        validate_source!
+        create_workspace!
+        copy_source!
+        init_git!
+      end
+
+      def teardown
+        FileUtils.rm_rf(@workspace_path) if Dir.exist?(@workspace_path)
+      end
+
+      private
+
+      def validate_source!
+        unless Dir.exist?(@source_path)
+          raise SmartBox::Error, "Source directory not found: #{@source_path}"
+        end
+
+        # For copy mode we allow non-git sources, no extra check needed.
+      end
+
+      def create_workspace!
+        FileUtils.mkdir_p(@workspace_path)
+      end
+
+      def copy_source!
+        # Use FileUtils.cp_r with a filter to skip excluded directories.
+        # Walk through each entry in the source directory
+        Dir.each_child(@source_path) do |entry|
+          # Skip excluded dirs/files at the top level
+          next if EXCLUDE_DIRS.include?(entry)
+
+          # Skip vendor/bundle — it's a nested pattern; handle at top-level
+          # since we only walk one level deep via each_child
+          next if entry == "vendor"
+
+          src  = File.join(@source_path, entry)
+          dest = File.join(@workspace_path, entry)
+
+          if File.directory?(src)
+            # vendor directory: copy but skip vendor/bundle
+            if entry == "vendor"
+              FileUtils.mkdir_p(dest)
+              Dir.each_child(src) do |sub|
+                next if sub == "bundle"
+                FileUtils.cp_r(File.join(src, sub), File.join(dest, sub))
+              end
+            else
+              FileUtils.cp_r(src, dest)
+            end
+          else
+            FileUtils.cp_r(src, dest)
+          end
+        end
+      end
+
+      def init_git!
+        Dir.chdir(@workspace_path) do
+          system("git", "init", out: File::NULL, err: File::NULL)
+          system("git", "config", "user.email", "smart_box@localhost", out: File::NULL, err: File::NULL)
+          system("git", "config", "user.name", "smart_box", out: File::NULL, err: File::NULL)
+          system("git", "add", "-A", out: File::NULL, err: File::NULL)
+          system("git", "commit", "-m", "smart_box initial checkpoint", out: File::NULL, err: File::NULL)
+        end
+      end
+    end
+  end
+end