smart_box 0.1.1

data/lib/smart_box/modes/git_worktree_mode.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module SmartBox
+  module Modes
+    class GitWorktreeMode
+      attr_reader :source_path, :workspace_path, :branch_name
+
+      def initialize(source_path:, workspace_path:, box_id:)
+        @source_path    = File.expand_path(source_path)
+        @workspace_path = File.expand_path(workspace_path)
+        @box_id         = box_id
+        @branch_name    = "smart-box/#{box_id}"
+      end
+
+      # --- entry points ---
+
+      def setup
+        validate_source!
+        ensure_branch!
+        create_worktree!
+        init_checkpoint!
+      end
+
+      def teardown
+        remove_worktree! if worktree_exists?
+      end
+
+      private
+
+      def validate_source!
+        unless Dir.exist?(@source_path)
+          raise SmartBox::Error, "Source directory not found: #{@source_path}"
+        end
+
+        unless Dir.exist?(File.join(@source_path, ".git"))
+          raise SmartBox::Error, "Source is not a git repository. git-worktree mode requires a git repo."
+        end
+
+        # Check if source is clean
+        unless source_clean?
+          raise DirtySourceError,
+            "Source project has uncommitted changes.\n" \
+            "Commit or stash your changes before creating a git-worktree box, " \
+            "or use copy mode instead."
+        end
+      end
+
+      def source_clean?
+        Dir.chdir(@source_path) do
+          `git status --porcelain 2>/dev/null`.strip.empty?
+        end
+      end
+
+      def ensure_branch!
+        Dir.chdir(@source_path) do
+          branches = `git branch --list #{@branch_name} 2>/dev/null`.strip
+          if branches.empty?
+            system("git", "branch", @branch_name, out: File::NULL, err: File::NULL)
+          end
+        end
+      end
+
+      def create_worktree!
+        Dir.chdir(@source_path) do
+          system("git", "worktree", "add", @workspace_path, @branch_name,
+                 out: File::NULL, err: File::NULL)
+        end
+
+        unless Dir.exist?(@workspace_path)
+          raise SmartBox::Error, "Failed to create git worktree at #{@workspace_path}"
+        end
+      end
+
+      def init_checkpoint!
+        Dir.chdir(@workspace_path) do
+          system("git", "add", "-A", out: File::NULL, err: File::NULL)
+          system("git", "commit", "--allow-empty", "-m", "smart_box initial checkpoint",
+                 out: File::NULL, err: File::NULL)
+        end
+      end
+
+      def remove_worktree!
+        Dir.chdir(@source_path) do
+          system("git", "worktree", "remove", @workspace_path, "--force",
+                 out: File::NULL, err: File::NULL)
+          system("git", "branch", "-D", @branch_name,
+                 out: File::NULL, err: File::NULL)
+        end
+      end
+
+      def worktree_exists?
+        Dir.chdir(@source_path) do
+          worktrees = `git worktree list --porcelain 2>/dev/null`
+          worktrees.include?(@workspace_path)
+        end
+      end
+    end
+  end
+end

data/lib/smart_box/runner.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+require "time"
+require "shellwords"
+require_relative "command_result"
+require_relative "errors"
+
+module SmartBox
+  class Runner
+    # Simple dangerous command patterns (string matching per design spec §12.1)
+    DANGEROUS_PATTERNS = [
+      /\brm\s+-rf\s+\//,
+      /\bmkfs\b/,
+      /\bdd\s+if=/,
+      /\bshutdown\b/,
+      /\breboot\b/,
+      /\bsudo\b/,
+      /\bchmod\s+-R\s+777\s+\//,
+      /\bchown\s+-R\b/
+    ].freeze
+
+    attr_reader :box_id, :workspace_path, :logs_dir
+
+    def initialize(box_id:, workspace_path:, logs_dir:)
+      @box_id         = box_id
+      @workspace_path = File.expand_path(workspace_path)
+      @logs_dir       = File.expand_path(logs_dir)
+      @command_index  = 0
+    end
+
+    # --- main entry point ---
+
+    def run(command, env: {}, timeout: nil, allow_dangerous: false)
+      unless allow_dangerous
+        check_dangerous!(command)
+      end
+
+      started_at = Time.now
+      @command_index += 1
+      idx = @command_index
+
+      result = execute_command(command, env, timeout, started_at, idx)
+      write_logs(command, result, idx)
+
+      result
+    end
+
+    private
+
+    def check_dangerous!(command)
+      DANGEROUS_PATTERNS.each do |pattern|
+        if command.match?(pattern)
+          raise DangerousCommandError,
+            "Dangerous command detected: #{command.inspect}\n" \
+            "Use --allow-dangerous to bypass this check."
+        end
+      end
+    end
+
+    def execute_command(command, env, timeout, started_at, idx)
+      stdout_path = File.join(@logs_dir, "#{format('%04d', idx)}.stdout.log")
+      stderr_path = File.join(@logs_dir, "#{format('%04d', idx)}.stderr.log")
+
+      FileUtils.mkdir_p(@logs_dir)
+
+      stdout = ""
+      stderr = ""
+      exit_code = nil
+
+      Dir.chdir(@workspace_path) do
+        args = Shellwords.split(command)
+        if env && !env.empty?
+          stdout, stderr, status = Open3.capture3(env, *args, chdir: @workspace_path)
+        else
+          stdout, stderr, status = Open3.capture3(*args, chdir: @workspace_path)
+        end
+        exit_code = status.exitstatus
+      rescue Errno::ENOENT => e
+        stderr = "Command not found: #{e.message}"
+        exit_code = 127
+      end
+
+      ended_at = Time.now
+
+      File.write(stdout_path, stdout)
+      File.write(stderr_path, stderr)
+
+      CommandResult.new(
+        command:    command,
+        cwd:        @workspace_path,
+        stdout:     stdout,
+        stderr:     stderr,
+        exit_code:  exit_code,
+        started_at: started_at,
+        ended_at:   ended_at
+      )
+    end
+
+    def write_logs(command, result, idx)
+      write_human_log(command, result)
+      write_jsonl_log(command, result, idx)
+    end
+
+    def write_human_log(command, result)
+      log_path = File.join(@logs_dir, "commands.log")
+      FileUtils.mkdir_p(@logs_dir)
+
+      entry = <<~ENTRY
+        [#{result.started_at.strftime('%Y-%m-%d %H:%M:%S')}] RUN #{command}
+        cwd: #{result.cwd}
+        exit_code: #{result.exit_code}
+
+        STDOUT:
+        #{result.stdout.strip.empty? ? '(empty)' : result.stdout.strip}
+
+        STDERR:
+        #{result.stderr.strip.empty? ? '(empty)' : result.stderr.strip}
+
+      ENTRY
+
+      File.open(log_path, "a") { |f| f.write(entry) }
+    end
+
+    def write_jsonl_log(command, result, idx)
+      log_path = File.join(@logs_dir, "commands.jsonl")
+      FileUtils.mkdir_p(@logs_dir)
+
+      entry = {
+        "time"         => result.started_at.iso8601,
+        "box_id"       => @box_id,
+        "event"        => "command_finished",
+        "command"      => command,
+        "cwd"          => result.cwd,
+        "exit_code"    => result.exit_code,
+        "elapsed_ms"   => result.elapsed_ms,
+        "stdout_path"  => "logs/#{format('%04d', idx)}.stdout.log",
+        "stderr_path"  => "logs/#{format('%04d', idx)}.stderr.log"
+      }
+
+      File.open(log_path, "a") { |f| f.puts(JSON.generate(entry)) }
+    end
+  end
+end

data/lib/smart_box/version.rb

@@ -0,0 +1,3 @@
+module SmartBox
+  VERSION = "0.1.1"
+end

data/lib/smart_box.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "smart_box/version"
+require_relative "smart_box/errors"
+require_relative "smart_box/metadata"
+require_relative "smart_box/command_result"
+require_relative "smart_box/runner"
+require_relative "smart_box/modes/copy_mode"
+require_relative "smart_box/modes/git_worktree_mode"
+require_relative "smart_box/box"

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: smart_box
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- SmartBox Team
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  smart_box is a local sandbox system for Coding Agents. It allows agents to
+  perform file modifications, command execution, dependency installation,
+  experimental fixes, code generation, diff viewing, checkpoint rollback,
+  and patch export without directly polluting the real project directory.
+executables:
+- smart_box
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/smart_box
+- lib/smart_box.rb
+- lib/smart_box/box.rb
+- lib/smart_box/cli.rb
+- lib/smart_box/command_result.rb
+- lib/smart_box/errors.rb
+- lib/smart_box/metadata.rb
+- lib/smart_box/modes/copy_mode.rb
+- lib/smart_box/modes/git_worktree_mode.rb
+- lib/smart_box/runner.rb
+- lib/smart_box/version.rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/smart-box/smart_box
+  changelog_uri: https://github.com/smart-box/smart_box/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.13
+specification_version: 4
+summary: A local reversible sandbox system for agent task execution
+test_files: []