lex-exec 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0e24d56db8e7444e6ea2af9d29b91a509d95aabac9f057dcc6dd4ec8c2c886e
-  data.tar.gz: 15efcf34aae86cd254501fd976511d77de01acf5202b8bd0f87156f0cd03d46d
+  metadata.gz: 64b870afb59925733e75c02a7266776140f4feba23ac608703d31553409c36ed
+  data.tar.gz: 4b9c602faa2f3dd110012d18312f42880940a73d1cb518acac75b0100700eefb
 SHA512:
-  metadata.gz: 7381db9bc39961927fff09796a591b3f18e104ade241f3a174bb9a3047a2737af8332cdd3b98c407bc42a5eb29eb6a5c47b53e5e76a9b486f41ed9050480c182
-  data.tar.gz: 7a73b0059b112190168c19e60b1aff03015fda95ad09de69c88f6f6972f87cefb2d5949b329b7d1fdf5a2a0b2af2167f02625d6f6e331871579881f5173d8369
+  metadata.gz: 60981006cc6d04c67e9f33f1c02904828065d6e5e0eec8b43265ba7db7137a8254e6810e1fca2615021a82d1884f3614b11af3d3c1a1ddb2b26b9180d172e48b
+  data.tar.gz: 7ea77c999a1596b1993e9501fd24d4800ff4eea3877c948236b309fb9225c0c1190e341856cfe1801e3a7f11cecede97576ec61dd178de8cdc7f2282c2b9f025

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.1.9] - 2026-04-13
+
+### Added
+- `Git.clone` — shallow/branched clone with depth read from `Legion::Settings.dig(:fleet, :git, :depth)`
+- `Git.fetch` — `git fetch --all --prune` or named remote
+- `Git.checkout` — checkout ref or create new branch with `-b`
+- `Worktree.create/remove/list` — `repo_path:` parameter passes `chdir:` to `Open3.capture3` for shared-worker correctness
+- `Helpers::RepoMaterializer` — strategy-based repo materialization (`materialize/release`); Phase 1 implements `:clone` strategy with `credential_provider` injection
+- `worktree_path` now checks `Legion::Settings.dig(:fleet, :workspace, :worktree_base)` before falling back to `:worktree, :base_dir`
+
 ## [0.1.8] - 2026-04-09
 
 ### Changed

data/lib/legion/extensions/exec/helpers/repo_materializer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Legion
+  module Extensions
+    module Exec
+      module Helpers
+        module RepoMaterializer
+          class << self
+            def materialize(work_item:, credential_provider: nil)
+              strategy = resolve_strategy
+              case strategy
+              when :clone
+                materialize_via_clone(work_item: work_item, credential_provider: credential_provider)
+              else
+                { success: false, error: "Unknown strategy: #{strategy}" }
+              end
+            end
+
+            def release(work_item:)
+              repo_path = build_repo_path(work_item)
+              Helpers::Worktree.remove(task_id: work_item[:task_id], repo_path: repo_path)
+            end
+
+            private
+
+            def resolve_strategy
+              raw = Legion::Settings.dig(:fleet, :materialization, :strategy) if defined?(Legion::Settings)
+              (raw || :clone).to_sym
+            end
+
+            def materialize_via_clone(work_item:, credential_provider:)
+              url = apply_credentials(work_item[:repo_url], credential_provider)
+              depth = Legion::Settings.dig(:fleet, :git, :depth) if defined?(Legion::Settings)
+              repo_path = build_repo_path(work_item)
+
+              begin
+                ::FileUtils.mkdir_p(::File.dirname(repo_path))
+              rescue StandardError => e
+                return { success: false, reason: :mkdir_failed, error: e.message }
+              end
+
+              clone_result = Runners::Git.clone(url: url, path: repo_path, depth: depth)
+              unless clone_result[:success]
+                return {
+                  success:      false,
+                  error:        clone_result[:stderr] || clone_result[:reason] || clone_result[:error],
+                  reason:       clone_result[:reason],
+                  stderr:       clone_result[:stderr],
+                  clone_result: clone_result
+                }
+              end
+
+              worktree_result = Helpers::Worktree.create(
+                task_id:   work_item[:task_id],
+                branch:    work_item[:branch],
+                base_ref:  work_item[:base_ref] || 'HEAD',
+                repo_path: repo_path
+              )
+              return { success: false, error: worktree_result[:message] } unless worktree_result[:success]
+
+              { success: true, workspace_path: worktree_result[:path], branch: worktree_result[:branch], repo_path: repo_path }
+            end
+
+            def apply_credentials(url, credential_provider)
+              return url unless credential_provider
+
+              result = credential_provider.call(url)
+              raise ArgumentError, 'credential_provider must return a non-empty String URL' unless result.is_a?(String) && !result.empty?
+
+              result
+            end
+
+            def build_repo_path(work_item)
+              base = (Legion::Settings.dig(:fleet, :workspace, :repo_base) if defined?(Legion::Settings))
+              base ||= '/tmp/legion-repos'
+              repo_name = ::File.basename(work_item[:repo_url], '.git')
+              ::File.join(base, work_item[:task_id].to_s, repo_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/exec/helpers/worktree.rb

@@ -9,40 +9,59 @@ module Legion
       module Helpers
         module Worktree
           class << self
-            def create(task_id:, branch: nil, base_ref: 'HEAD')
+            def create(task_id:, branch: nil, base_ref: 'HEAD', repo_path: nil)
               branch ||= "legion/#{task_id}"
               path = worktree_path(task_id)
               return { success: false, reason: :already_exists } if Dir.exist?(path)
 
               FileUtils.mkdir_p(File.dirname(path))
-              _stdout, stderr, status = Open3.capture3('git', 'worktree', 'add', path, '-b', branch, base_ref)
+              args = ['git', 'worktree', 'add', path, '-b', branch, base_ref]
+              opts = repo_path ? { chdir: repo_path } : {}
+              _stdout, stderr, status = Open3.capture3(*args, **opts)
               if status.success?
                 { success: true, path: path, branch: branch }
               else
                 { success: false, reason: :git_error, message: stderr.strip }
               end
+            rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES => e
+              { success: false, reason: :invalid_repo_path, message: e.message }
             end
 
-            def remove(task_id:)
+            def remove(task_id:, repo_path: nil)
               path = worktree_path(task_id)
               return { success: false, reason: :not_found } unless Dir.exist?(path)
 
-              _stdout, stderr, status = Open3.capture3('git', 'worktree', 'remove', path, '--force')
+              args = ['git', 'worktree', 'remove', path, '--force']
+              opts = repo_path ? { chdir: repo_path } : {}
+              _stdout, stderr, status = Open3.capture3(*args, **opts)
               if status.success?
                 { success: true }
               else
                 { success: false, reason: :git_error, message: stderr.strip }
               end
+            rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES => e
+              { success: false, reason: :invalid_repo_path, message: e.message }
             end
 
-            def list
-              stdout, _stderr, _status = Open3.capture3('git', 'worktree', 'list', '--porcelain')
-              worktrees = parse_worktree_list(stdout)
-              { success: true, worktrees: worktrees }
+            def list(repo_path: nil)
+              args = ['git', 'worktree', 'list', '--porcelain']
+              opts = repo_path ? { chdir: repo_path } : {}
+              stdout, stderr, status = Open3.capture3(*args, **opts)
+              if status.success?
+                worktrees = parse_worktree_list(stdout)
+                { success: true, worktrees: worktrees }
+              else
+                { success: false, reason: :git_error, message: stderr.strip }
+              end
+            rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES => e
+              { success: false, reason: :invalid_repo_path, message: e.message }
             end
 
             def worktree_path(task_id)
-              base = Legion::Settings.dig(:worktree, :base_dir) if defined?(Legion::Settings)
+              base = if defined?(Legion::Settings)
+                       Legion::Settings.dig(:fleet, :workspace, :worktree_base) ||
+                         Legion::Settings.dig(:worktree, :base_dir)
+                     end
               File.join(base || File.join(Dir.pwd, '.legion-worktrees'), task_id.to_s)
             end
 

data/lib/legion/extensions/exec/runners/git.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'shellwords'
+
 module Legion
   module Extensions
     module Exec
@@ -41,6 +43,26 @@ module Legion
               cwd:     Dir.pwd
             )
           end
+
+          def clone(url:, path:, depth: nil, branch: nil, **)
+            resolved_depth = depth
+            resolved_depth ||= Legion::Settings.dig(:fleet, :git, :depth) if defined?(Legion::Settings)
+            args = ['git clone']
+            args << "--depth #{resolved_depth}" if resolved_depth
+            args << "--branch #{Shellwords.shellescape(branch)}" if branch
+            args << Shellwords.shellescape(url) << Shellwords.shellescape(path)
+            Runners::Shell.execute(command: args.join(' '), cwd: Dir.pwd)
+          end
+
+          def fetch(path:, remote: nil, **)
+            cmd = remote ? "git fetch #{Shellwords.shellescape(remote)} --prune" : 'git fetch --all --prune'
+            Runners::Shell.execute(command: cmd, cwd: path)
+          end
+
+          def checkout(path:, ref:, create: false, **)
+            flag = create ? ' -b' : ''
+            Runners::Shell.execute(command: "git checkout#{flag} #{Shellwords.shellescape(ref)}", cwd: path)
+          end
         end
       end
     end

data/lib/legion/extensions/exec/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Exec
-      VERSION = '0.1.8'
+      VERSION = '0.1.9'
     end
   end
 end

data/lib/legion/extensions/exec.rb

@@ -8,6 +8,7 @@ require_relative 'exec/helpers/result_parser'
 require_relative 'exec/helpers/audit_log'
 require_relative 'exec/helpers/checkpoint'
 require_relative 'exec/helpers/worktree'
+require_relative 'exec/helpers/repo_materializer'
 require_relative 'exec/runners/shell'
 require_relative 'exec/runners/git'
 require_relative 'exec/runners/bundler'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-exec
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Esity
@@ -131,6 +131,7 @@ files:
 - lib/legion/extensions/exec/helpers/audit_log.rb
 - lib/legion/extensions/exec/helpers/checkpoint.rb
 - lib/legion/extensions/exec/helpers/constants.rb
+- lib/legion/extensions/exec/helpers/repo_materializer.rb
 - lib/legion/extensions/exec/helpers/result_parser.rb
 - lib/legion/extensions/exec/helpers/sandbox.rb
 - lib/legion/extensions/exec/helpers/worktree.rb