lex-exec 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0e24d56db8e7444e6ea2af9d29b91a509d95aabac9f057dcc6dd4ec8c2c886e
-  data.tar.gz: 15efcf34aae86cd254501fd976511d77de01acf5202b8bd0f87156f0cd03d46d
+  metadata.gz: 99f24f743720335d307955a43fafde85fb5eb89e40f169d7b800c48fe47eb24f
+  data.tar.gz: 816a4d2cbb3a04fa7dd1c62f689896a4671ad1042275bad1abd68d8cc0911a6c
 SHA512:
-  metadata.gz: 7381db9bc39961927fff09796a591b3f18e104ade241f3a174bb9a3047a2737af8332cdd3b98c407bc42a5eb29eb6a5c47b53e5e76a9b486f41ed9050480c182
-  data.tar.gz: 7a73b0059b112190168c19e60b1aff03015fda95ad09de69c88f6f6972f87cefb2d5949b329b7d1fdf5a2a0b2af2167f02625d6f6e331871579881f5173d8369
+  metadata.gz: 24bf7e41c0eca3212b1c17aed5995fe8b922a337832899a152a5fdf9662e35b4b5096a6d7ca06df022f9822e0cb787f96052e69e742a609be2735ba962e4f802
+  data.tar.gz: 1cdc824440473fa2ee65fe0c23336cf81ed25974007051174eaf836ca57a43ac93ef81179663c79df9c4a50f92365fe96d38bfa21c7b9de6eb1edd57f5180dd9

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.1.10] - 2026-05-23
+
+### Added
+- Runner definition metadata for Shell, Git, Bundler, and Filesystem operations.
+- Filesystem runner wrappers for common local commands including `pwd`, `ls`, `mkdir`, `touch`, `cat`, `head`, `tail`, `wc`, `cp`, `mv`, and `rm`.
+- Git runner wrappers for `diff`, `branch`, `log`, and `show`.
+
+### Changed
+- Shell-escape Git command arguments for staging, commits, repository creation, and filtered diffs.
+
+## [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/README.md

@@ -18,13 +18,14 @@ gem install lex-exec
 
 ## Overview
 
-`lex-exec` provides three runners:
+`lex-exec` provides four runners:
 
 - **Shell** - Execute arbitrary shell commands against an allowlist
-- **Git** - Common git operations (init, add, commit, push, status, create_repo)
+- **Git** - Common git operations (init, add, commit, push, status, diff, branch, log, show, create_repo)
+- **Filesystem** - Native wrappers for common file commands (`pwd`, `ls`, `mkdir`, `touch`, `cat`, `head`, `tail`, `wc`, `cp`, `mv`, `rm`)
 - **Bundler** - Run `bundle install`, `rspec`, and `rubocop` with structured output parsing
 
-All shell execution goes through a `Sandbox` that checks the base command against an allowlist and rejects commands matching blocked patterns. Every execution is recorded in a thread-safe in-memory `AuditLog`.
+All runner methods expose Legion definition metadata (`mcp_prefix`, category, inputs, idempotency, and trigger words) so the extension can be discovered as native tools. All shell execution goes through a `Sandbox` that checks the base command against an allowlist and rejects commands matching blocked patterns. Every execution is recorded in a thread-safe in-memory `AuditLog`.
 
 ## Allowlisted Commands
 
@@ -33,6 +34,7 @@ Only the following base commands are permitted:
 ```
 bundle  git  gh  ruby  rspec  rubocop
 ls  cat  mkdir  cp  mv  rm  touch  echo  wc  head  tail
+pwd  python3  pip3
 ```
 
 Commands not in this list are rejected before execution with `success: false, error: :blocked`.
@@ -94,8 +96,19 @@ client.add(files: ['lib/foo.rb', 'spec/foo_spec.rb'])
 client.commit(message: 'add foo runner')
 client.push(remote: 'origin', branch: 'main', set_upstream: true)
 client.status
+client.diff(staged: true)
+client.branch(all: true)
+client.log(max_count: 10)
+client.show(ref: 'HEAD')
 client.create_repo(name: 'lex-foo', org: 'LegionIO', description: 'foo extension', public: true)
 
+# Filesystem
+client.pwd
+client.ls(path: '/path/to/project', all: true, long: true)
+client.mkdir(path: '/path/to/project/tmp/reports')
+client.cat(path: '/path/to/project/README.md')
+client.head(path: '/path/to/project/CHANGELOG.md', lines: 20)
+
 # Bundler
 client.install
 client.exec_rspec(format: 'progress')
@@ -121,6 +134,12 @@ Legion::Extensions::Exec::Runners::Git.push(path: '/path/to/dir', remote: 'origi
 # Status (parses --porcelain output into structured form)
 Legion::Extensions::Exec::Runners::Git.status(path: '/path/to/dir')
 
+# Diff, branch, log, and show
+Legion::Extensions::Exec::Runners::Git.diff(path: '/path/to/dir', staged: true)
+Legion::Extensions::Exec::Runners::Git.branch(path: '/path/to/dir', all: true)
+Legion::Extensions::Exec::Runners::Git.log(path: '/path/to/dir', max_count: 20)
+Legion::Extensions::Exec::Runners::Git.show(path: '/path/to/dir', ref: 'HEAD')
+
 # Create GitHub repo via gh CLI
 Legion::Extensions::Exec::Runners::Git.create_repo(
   name:        'lex-myext',
@@ -130,6 +149,22 @@ Legion::Extensions::Exec::Runners::Git.create_repo(
 )
 ```
 
+### Filesystem runner
+
+```ruby
+Legion::Extensions::Exec::Runners::Filesystem.pwd(path: '/path/to/project')
+Legion::Extensions::Exec::Runners::Filesystem.ls(path: '/path/to/project', all: true, long: true)
+Legion::Extensions::Exec::Runners::Filesystem.mkdir(path: '/path/to/project/tmp/reports')
+Legion::Extensions::Exec::Runners::Filesystem.touch(path: '/path/to/project/tmp/report.txt')
+Legion::Extensions::Exec::Runners::Filesystem.cat(path: '/path/to/project/README.md')
+Legion::Extensions::Exec::Runners::Filesystem.head(path: '/path/to/project/CHANGELOG.md', lines: 20)
+Legion::Extensions::Exec::Runners::Filesystem.tail(path: '/path/to/project/log/development.log', lines: 50)
+Legion::Extensions::Exec::Runners::Filesystem.wc(path: '/path/to/project/README.md')
+Legion::Extensions::Exec::Runners::Filesystem.cp(source: '/tmp/a.txt', destination: '/tmp/b.txt')
+Legion::Extensions::Exec::Runners::Filesystem.mv(source: '/tmp/b.txt', destination: '/tmp/c.txt')
+Legion::Extensions::Exec::Runners::Filesystem.rm(path: '/tmp/c.txt')
+```
+
 ### Bundler runner
 
 ```ruby

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

@@ -38,10 +38,71 @@ module Legion
           Runners::Git.status(path: path)
         end
 
+        def diff(path: @base_path, **)
+          Runners::Git.diff(path: path, **)
+        end
+
+        def branch(path: @base_path, **)
+          Runners::Git.branch(path: path, **)
+        end
+
+        def log(path: @base_path, **)
+          Runners::Git.log(path: path, **)
+        end
+
+        def show(path: @base_path, **)
+          Runners::Git.show(path: path, **)
+        end
+
         def create_repo(**)
           Runners::Git.create_repo(**)
         end
 
+        # Filesystem delegation
+        def pwd(path: @base_path, **)
+          Runners::Filesystem.pwd(path: path, **)
+        end
+
+        def ls(path: @base_path, **)
+          Runners::Filesystem.ls(path: path, **)
+        end
+
+        def mkdir(path:, **)
+          Runners::Filesystem.mkdir(path: path, **)
+        end
+
+        def touch(path:, **)
+          Runners::Filesystem.touch(path: path, **)
+        end
+
+        def cat(path:, **)
+          Runners::Filesystem.cat(path: path, **)
+        end
+
+        def head(path:, **)
+          Runners::Filesystem.head(path: path, **)
+        end
+
+        def tail(path:, **)
+          Runners::Filesystem.tail(path: path, **)
+        end
+
+        def wc(path:, **)
+          Runners::Filesystem.wc(path: path, **)
+        end
+
+        def cp(source:, destination:, **)
+          Runners::Filesystem.cp(source: source, destination: destination, **)
+        end
+
+        def mv(source:, destination:, **)
+          Runners::Filesystem.mv(source: source, destination: destination, **)
+        end
+
+        def rm(path:, **)
+          Runners::Filesystem.rm(path: path, **)
+        end
+
         # Bundler delegation
         def install(path: @base_path, **)
           Runners::Bundler.install(path: path)

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

@@ -13,7 +13,7 @@ module Legion
 
           BASE_ALLOWED_COMMANDS = %w[
             bundle git gh ruby rspec rubocop ls cat mkdir cp mv rm touch echo wc head tail
-            python3 pip3
+            pwd python3 pip3
           ].freeze
 
           VENV_ALLOWED_COMMANDS = [

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/bundler.rb

@@ -5,12 +5,36 @@ module Legion
     module Exec
       module Runners
         module Bundler # rubocop:disable Legion/Extension/RunnerIncludeHelpers
+          extend Legion::Extensions::Definitions
+
           module_function
 
+          def self.trigger_words
+            %w[bundle bundler gem gems install rspec rubocop test lint]
+          end
+
+          definition :install,
+                     desc:          'Run bundle install in a Ruby project',
+                     mcp_prefix:    'exec.bundler.install',
+                     mcp_category:  'exec_bundler',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path: { type: 'string' } }, required: ['path'] },
+                     trigger_words: %w[bundle install gems]
+
           def install(path:, **)
             Runners::Shell.execute(command: 'bundle install', cwd: path, timeout: 300_000)
           end
 
+          definition :exec_rspec,
+                     desc:          'Run bundle exec rspec and parse the suite summary',
+                     mcp_prefix:    'exec.bundler.exec_rspec',
+                     mcp_category:  'exec_bundler',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:   { type: 'string' },
+                                                    format: { type: 'string' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[rspec spec test suite]
+
           def exec_rspec(path:, format: 'progress', **)
             result = Runners::Shell.execute(
               command: "bundle exec rspec --format #{format}",
@@ -24,6 +48,16 @@ module Legion
             result.merge(parsed: parsed)
           end
 
+          definition :exec_rubocop,
+                     desc:          'Run bundle exec rubocop with optional autocorrect and parse offenses',
+                     mcp_prefix:    'exec.bundler.exec_rubocop',
+                     mcp_category:  'exec_bundler',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:        { type: 'string' },
+                                                    autocorrect: { type: 'boolean' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[rubocop lint autocorrect offenses]
+
           def exec_rubocop(path:, autocorrect: false, **)
             cmd    = autocorrect ? 'bundle exec rubocop -A' : 'bundle exec rubocop'
             result = Runners::Shell.execute(command: cmd, cwd: path, timeout: 120_000)

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Legion
+  module Extensions
+    module Exec
+      module Runners
+        module Filesystem # rubocop:disable Legion/Extension/RunnerIncludeHelpers
+          extend Legion::Extensions::Definitions
+
+          module_function
+
+          def self.trigger_words
+            %w[file files filesystem directory directories ls list mkdir touch cat head tail wc cp mv rm]
+          end
+
+          definition :pwd,
+                     desc:          'Print the current working directory',
+                     mcp_prefix:    'exec.filesystem.pwd',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' } } },
+                     trigger_words: %w[pwd directory cwd]
+
+          def pwd(path: Dir.pwd, **)
+            Runners::Shell.execute(command: 'pwd', cwd: path)
+          end
+
+          definition :ls,
+                     desc:          'List files in a directory',
+                     mcp_prefix:    'exec.filesystem.ls',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' },
+                                                    all:  { type: 'boolean' },
+                                                    long: { type: 'boolean' } } },
+                     trigger_words: %w[ls list files directory]
+
+          def ls(path: Dir.pwd, all: false, long: false, **)
+            flags = []
+            flags << 'a' if all
+            flags << 'l' if long
+
+            command = ['ls']
+            command << "-#{flags.join}" unless flags.empty?
+            command << Shellwords.shellescape(path)
+            Runners::Shell.execute(command: command.join(' '), cwd: Dir.pwd)
+          end
+
+          definition :mkdir,
+                     desc:          'Create a directory',
+                     mcp_prefix:    'exec.filesystem.mkdir',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:    { type: 'string' },
+                                                    parents: { type: 'boolean' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[mkdir create directory folder]
+
+          def mkdir(path:, parents: true, **)
+            flag = parents ? ' -p' : ''
+            Runners::Shell.execute(command: "mkdir#{flag} #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+
+          definition :touch,
+                     desc:          'Create or update a file timestamp',
+                     mcp_prefix:    'exec.filesystem.touch',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path: { type: 'string' } }, required: ['path'] },
+                     trigger_words: %w[touch create file]
+
+          def touch(path:, **)
+            Runners::Shell.execute(command: "touch #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+
+          definition :cat,
+                     desc:          'Read a file with cat',
+                     mcp_prefix:    'exec.filesystem.cat',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' } }, required: ['path'] },
+                     trigger_words: %w[cat read file]
+
+          def cat(path:, **)
+            Runners::Shell.execute(command: "cat #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+
+          definition :head,
+                     desc:          'Read the first lines of a file',
+                     mcp_prefix:    'exec.filesystem.head',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path:  { type: 'string' },
+                                                    lines: { type: 'integer' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[head first lines file]
+
+          def head(path:, lines: 20, **)
+            Runners::Shell.execute(command: "head -n #{Integer(lines)} #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+
+          definition :tail,
+                     desc:          'Read the last lines of a file',
+                     mcp_prefix:    'exec.filesystem.tail',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path:  { type: 'string' },
+                                                    lines: { type: 'integer' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[tail last lines file]
+
+          def tail(path:, lines: 20, **)
+            Runners::Shell.execute(command: "tail -n #{Integer(lines)} #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+
+          definition :wc,
+                     desc:          'Count lines, words, and bytes in a file',
+                     mcp_prefix:    'exec.filesystem.wc',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' } }, required: ['path'] },
+                     trigger_words: %w[wc count lines words bytes]
+
+          def wc(path:, **)
+            Runners::Shell.execute(command: "wc #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+
+          definition :cp,
+                     desc:          'Copy files or directories',
+                     mcp_prefix:    'exec.filesystem.cp',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { source:      { type: 'string' },
+                                                    destination: { type: 'string' },
+                                                    recursive:   { type: 'boolean' } },
+                                      required:   %w[source destination] },
+                     trigger_words: %w[copy cp file directory]
+
+          def cp(source:, destination:, recursive: false, **)
+            flag = recursive ? ' -R' : ''
+            Runners::Shell.execute(
+              command: "cp#{flag} #{Shellwords.shellescape(source)} #{Shellwords.shellescape(destination)}",
+              cwd:     Dir.pwd
+            )
+          end
+
+          definition :mv,
+                     desc:          'Move or rename files or directories',
+                     mcp_prefix:    'exec.filesystem.mv',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { source:      { type: 'string' },
+                                                    destination: { type: 'string' } },
+                                      required:   %w[source destination] },
+                     trigger_words: %w[move mv rename file directory]
+
+          def mv(source:, destination:, **)
+            Runners::Shell.execute(
+              command: "mv #{Shellwords.shellescape(source)} #{Shellwords.shellescape(destination)}",
+              cwd:     Dir.pwd
+            )
+          end
+
+          definition :rm,
+                     desc:          'Remove a file or directory through the sandbox blocklist',
+                     mcp_prefix:    'exec.filesystem.rm',
+                     mcp_category:  'exec_filesystem',
+                     mcp_tier:      :elevated,
+                     inputs:        { properties: { path:      { type: 'string' },
+                                                    recursive: { type: 'boolean' },
+                                                    force:     { type: 'boolean' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[remove delete rm file directory]
+
+          def rm(path:, recursive: false, force: false, **)
+            flags = []
+            flags << 'r' if recursive
+            flags << 'f' if force
+            flag = flags.empty? ? '' : " -#{flags.join}"
+            Runners::Shell.execute(command: "rm#{flag} #{Shellwords.shellescape(path)}", cwd: Dir.pwd)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,31 +1,86 @@
 # frozen_string_literal: true
 
+require 'shellwords'
+
 module Legion
   module Extensions
     module Exec
       module Runners
         module Git # rubocop:disable Legion/Extension/RunnerIncludeHelpers
+          extend Legion::Extensions::Definitions
+
           module_function
 
+          def self.trigger_words
+            %w[git repo repository status diff add commit branch checkout clone fetch push]
+          end
+
+          definition :init,
+                     desc:          'Initialize a git repository at the target path',
+                     mcp_prefix:    'exec.git.init',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path: { type: 'string' } }, required: ['path'] },
+                     trigger_words: %w[git init repository]
+
           def init(path:, **)
             Runners::Shell.execute(command: 'git init', cwd: path)
           end
 
+          definition :add,
+                     desc:          'Stage files in a git repository',
+                     mcp_prefix:    'exec.git.add',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:  { type: 'string' },
+                                                    files: { type: %w[string array] } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git add stage files]
+
           def add(path:, files: '.', **)
-            cmd = files == '.' ? 'git add -A' : "git add #{Array(files).join(' ')}"
+            cmd = files == '.' ? 'git add -A' : "git add #{shellwords_join(Array(files))}"
             Runners::Shell.execute(command: cmd, cwd: path)
           end
 
+          definition :commit,
+                     desc:          'Create a git commit with a message',
+                     mcp_prefix:    'exec.git.commit',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:    { type: 'string' },
+                                                    message: { type: 'string' } },
+                                      required:   %w[path message] },
+                     trigger_words: %w[git commit message]
+
           def commit(path:, message:, **)
-            safe_msg = message.gsub("'", "\\'")
-            Runners::Shell.execute(command: "git commit -m '#{safe_msg}'", cwd: path)
+            Runners::Shell.execute(command: "git commit -m #{Shellwords.shellescape(message)}", cwd: path)
           end
 
-          def push(path:, remote: 'origin', branch: 'main', set_upstream: false, **)
-            cmd = set_upstream ? "git push -u #{remote} #{branch}" : 'git push'
-            Runners::Shell.execute(command: cmd, cwd: path)
+          definition :push,
+                     desc:          'Push a git branch to a remote',
+                     mcp_prefix:    'exec.git.push',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:         { type: 'string' },
+                                                    remote:       { type: 'string' },
+                                                    branch:       { type: 'string' },
+                                                    set_upstream: { type: 'boolean' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git push remote upstream branch]
+
+          def push(path:, remote: nil, branch: nil, set_upstream: false, **)
+            Runners::Shell.execute(command: push_command(remote: remote, branch: branch, set_upstream: set_upstream), cwd: path)
           end
 
+          definition :status,
+                     desc:          'Return git porcelain status and parsed working tree state',
+                     mcp_prefix:    'exec.git.status',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' } }, required: ['path'] },
+                     trigger_words: %w[git status changes working-tree]
+
           def status(path:, **)
             result = Runners::Shell.execute(command: 'git status --porcelain', cwd: path)
             return result unless result[:success] # rubocop:disable Legion/Extension/RunnerReturnHash
@@ -34,13 +89,162 @@ module Legion
             result.merge(parsed: parsed)
           end
 
+          definition :diff,
+                     desc:          'Show unstaged, staged, or ref-specific git diff output',
+                     mcp_prefix:    'exec.git.diff',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path:   { type: 'string' },
+                                                    staged: { type: 'boolean' },
+                                                    ref:    { type: 'string' },
+                                                    files:  { type: %w[string array] } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git diff patch changes staged]
+
+          def diff(path:, staged: false, ref: nil, files: nil, **)
+            args = ['git diff']
+            args << '--cached' if staged
+            args << Shellwords.shellescape(ref) if ref
+            args << '--' if files
+            args << shellwords_join(Array(files)) if files
+            Runners::Shell.execute(command: args.join(' '), cwd: path)
+          end
+
+          definition :branch,
+                     desc:          'List local or all git branches',
+                     mcp_prefix:    'exec.git.branch',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' },
+                                                    all:  { type: 'boolean' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git branch branches]
+
+          def branch(path:, all: false, **)
+            command = all ? 'git branch --all' : 'git branch'
+            Runners::Shell.execute(command: command, cwd: path)
+          end
+
+          definition :log,
+                     desc:          'Show recent git commit history',
+                     mcp_prefix:    'exec.git.log',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path:      { type: 'string' },
+                                                    max_count: { type: 'integer' },
+                                                    oneline:   { type: 'boolean' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git log history commits]
+
+          def log(path:, max_count: 20, oneline: true, **)
+            args = ['git log', "--max-count=#{Integer(max_count)}"]
+            args << '--oneline' if oneline
+            Runners::Shell.execute(command: args.join(' '), cwd: path)
+          end
+
+          definition :show,
+                     desc:          'Show a git object, commit, or ref',
+                     mcp_prefix:    'exec.git.show',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path: { type: 'string' },
+                                                    ref:  { type: 'string' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git show commit ref]
+
+          def show(path:, ref: 'HEAD', **)
+            Runners::Shell.execute(command: "git show #{Shellwords.shellescape(ref)}", cwd: path)
+          end
+
+          definition :create_repo,
+                     desc:          'Create and clone a GitHub repository using gh',
+                     mcp_prefix:    'exec.git.create_repo',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { name:        { type: 'string' },
+                                                    org:         { type: 'string' },
+                                                    description: { type: 'string' },
+                                                    public:      { type: 'boolean' } },
+                                      required:   ['name'] },
+                     trigger_words: %w[github repo create clone]
+
           def create_repo(name:, org: 'LegionIO', description: '', public: true, **)
             visibility = public ? '--public' : '--private'
             Runners::Shell.execute(
-              command: "gh repo create #{org}/#{name} #{visibility} --description '#{description}' --clone",
+              command: "gh repo create #{Shellwords.shellescape("#{org}/#{name}")} #{visibility} --description #{Shellwords.shellescape(description)} --clone",
               cwd:     Dir.pwd
             )
           end
+
+          definition :clone,
+                     desc:          'Clone a git repository with optional depth and branch',
+                     mcp_prefix:    'exec.git.clone',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { url:    { type: 'string' },
+                                                    path:   { type: 'string' },
+                                                    depth:  { type: 'integer' },
+                                                    branch: { type: 'string' } },
+                                      required:   %w[url path] },
+                     trigger_words: %w[git clone repository checkout]
+
+          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
+
+          definition :fetch,
+                     desc:          'Fetch git remotes and prune deleted branches',
+                     mcp_prefix:    'exec.git.fetch',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { path:   { type: 'string' },
+                                                    remote: { type: 'string' } },
+                                      required:   ['path'] },
+                     trigger_words: %w[git fetch remote prune]
+
+          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
+
+          definition :checkout,
+                     desc:          'Checkout a git ref or create a branch',
+                     mcp_prefix:    'exec.git.checkout',
+                     mcp_category:  'exec_git',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { path:   { type: 'string' },
+                                                    ref:    { type: 'string' },
+                                                    create: { type: 'boolean' } },
+                                      required:   %w[path ref] },
+                     trigger_words: %w[git checkout switch branch]
+
+          def checkout(path:, ref:, create: false, **)
+            flag = create ? ' -b' : ''
+            Runners::Shell.execute(command: "git checkout#{flag} #{Shellwords.shellescape(ref)}", cwd: path)
+          end
+
+          def shellwords_join(values)
+            values.map { |value| Shellwords.shellescape(value.to_s) }.join(' ')
+          end
+
+          def push_command(remote:, branch:, set_upstream:)
+            args = ['git push']
+            args << '-u' if set_upstream
+            args << Shellwords.shellescape(remote) if remote
+            args << Shellwords.shellescape(branch) if branch
+            args.join(' ')
+          end
         end
       end
     end

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

@@ -8,8 +8,25 @@ module Legion
     module Exec
       module Runners
         module Shell
+          extend Legion::Extensions::Definitions
           extend self
 
+          def self.trigger_words
+            %w[shell command exec execute terminal bash run]
+          end
+
+          definition :execute,
+                     desc:          'Execute an allowlisted shell command in a working directory',
+                     mcp_prefix:    'exec.shell.execute',
+                     mcp_category:  'exec_shell',
+                     mcp_tier:      :standard,
+                     inputs:        { properties: { command: { type: 'string' },
+                                                    cwd:     { type: 'string' },
+                                                    timeout: { type: 'integer' },
+                                                    env:     { type: 'object' } },
+                                      required:   ['command'] },
+                     trigger_words: %w[shell command execute run terminal]
+
           def execute(command:, cwd: Dir.pwd, timeout: Helpers::Constants::DEFAULT_TIMEOUT, env: {}, **)
             check = default_sandbox.allowed?(command)
             return { success: false, error: :blocked, reason: check[:reason] } unless check[:allowed]
@@ -58,6 +75,15 @@ module Legion
             }
           end
 
+          definition :audit,
+                     desc:          'Return recent shell execution audit entries and aggregate stats',
+                     mcp_prefix:    'exec.shell.audit',
+                     mcp_category:  'exec_shell',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { limit: { type: 'integer' } } },
+                     trigger_words: %w[audit history shell executions]
+
           def audit(limit: 50, **)
             { success: true, entries: audit_log.entries(limit: limit), stats: audit_log.stats }
           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.10'
     end
   end
 end

data/lib/legion/extensions/exec.rb

@@ -1,6 +1,44 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+
+unless defined?(Legion::Extensions::Definitions)
+  module Legion
+    module Extensions
+      module Definitions
+        DEFAULTS = {
+          remote_invocable: true,
+          mcp_exposed:      true,
+          idempotent:       false,
+          risk_tier:        :standard,
+          tags:             [],
+          requires:         [],
+          inputs:           {},
+          outputs:          {}
+        }.freeze
+
+        def definition(method_name, **opts)
+          own_definitions[method_name.to_sym] = DEFAULTS.merge(opts)
+        end
+
+        def definitions
+          own_definitions.dup
+        end
+
+        def definition_for(method_name)
+          definitions[method_name.to_sym]
+        end
+
+        private
+
+        def own_definitions
+          @own_definitions ||= {}
+        end
+      end
+    end
+  end
+end
+
 require_relative 'exec/version'
 require_relative 'exec/helpers/constants'
 require_relative 'exec/helpers/sandbox'
@@ -8,9 +46,11 @@ 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'
+require_relative 'exec/runners/filesystem'
 require_relative 'exec/client'
 
 module Legion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-exec
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Esity
@@ -131,10 +131,12 @@ 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
 - lib/legion/extensions/exec/runners/bundler.rb
+- lib/legion/extensions/exec/runners/filesystem.rb
 - lib/legion/extensions/exec/runners/git.rb
 - lib/legion/extensions/exec/runners/shell.rb
 - lib/legion/extensions/exec/version.rb