grim-reaper 1.0.29

data/lib/grim_reaper/python_module.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module GrimReaper
+  # Python module wrapper for py_grim operations
+  class PythonModule
+    attr_reader :config, :grim_root
+
+    def initialize(config, grim_root)
+      @config = config
+      @grim_root = grim_root
+    end
+
+    def execute(command, *args)
+      case command
+      when "health"
+        execute_health
+      when "status"
+        execute_status
+      when "backup"
+        execute_backup(*args)
+      when "monitor"
+        execute_monitor(*args)
+      when "security"
+        execute_security(*args)
+      when "ai"
+        execute_ai(*args)
+      else
+        execute_generic(command, *args)
+      end
+    end
+
+    def status
+      {
+        status: "ready",
+        module: "python",
+        available_commands: %w[health status backup monitor security ai],
+        grim_root: @grim_root
+      }
+    end
+
+    private
+
+    def execute_health
+      script_path = File.join(@grim_root, "scythe", "scythe.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, "health", chdir: @grim_root)
+        {
+          command: "health",
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "python"
+        }
+      else
+        { error: "Scythe script not found", module: "python" }
+      end
+    end
+
+    def execute_status
+      script_path = File.join(@grim_root, "scythe", "scythe.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, "status", chdir: @grim_root)
+        {
+          command: "status",
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "python"
+        }
+      else
+        { error: "Scythe script not found", module: "python" }
+      end
+    end
+
+    def execute_backup(*args)
+      path = args.first || "/"
+      script_path = File.join(@grim_root, "scythe", "scythe.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, "backup", path, chdir: @grim_root)
+        {
+          command: "backup",
+          path: path,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "python"
+        }
+      else
+        { error: "Scythe script not found", module: "python" }
+      end
+    end
+
+    def execute_monitor(*args)
+      path = args.first || "/"
+      script_path = File.join(@grim_root, "py_grim", "grim_web", "app.py")
+      
+      if File.exist?(script_path)
+        # Start monitoring in background
+        pid = spawn("python3", script_path, chdir: @grim_root)
+        Process.detach(pid)
+        {
+          command: "monitor",
+          path: path,
+          pid: pid,
+          success: true,
+          module: "python"
+        }
+      else
+        { error: "Python web app not found", module: "python" }
+      end
+    end
+
+    def execute_security(*args)
+      script_path = File.join(@grim_root, "scythe", "scythe.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, "security", *args, chdir: @grim_root)
+        {
+          command: "security",
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "python"
+        }
+      else
+        { error: "Scythe script not found", module: "python" }
+      end
+    end
+
+    def execute_ai(*args)
+      script_path = File.join(@grim_root, "py_grim", "ai_decision_engine.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, *args, chdir: @grim_root)
+        {
+          command: "ai",
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "python"
+        }
+      else
+        { error: "AI script not found", module: "python" }
+      end
+    end
+
+    def execute_generic(command, *args)
+      script_path = File.join(@grim_root, "py_grim", "#{command}.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, *args, chdir: @grim_root)
+        {
+          command: command,
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "python"
+        }
+      else
+        { error: "Python script not found: #{command}.py", module: "python" }
+      end
+    end
+  end
+end 

data/lib/grim_reaper/security_module.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module GrimReaper
+  # Security module wrapper for scythe operations
+  class SecurityModule
+    attr_reader :config, :grim_root
+
+    def initialize(config, grim_root)
+      @config = config
+      @grim_root = grim_root
+    end
+
+    def execute(command, *args)
+      case command
+      when "audit"
+        execute_audit
+      when "scan"
+        execute_scan(*args)
+      when "encrypt"
+        execute_encrypt(*args)
+      when "decrypt"
+        execute_decrypt(*args)
+      when "quarantine"
+        execute_quarantine(*args)
+      when "threat"
+        execute_threat(*args)
+      else
+        execute_generic(command, *args)
+      end
+    end
+
+    def status
+      {
+        status: "ready",
+        module: "security",
+        available_commands: %w[audit scan encrypt decrypt quarantine threat],
+        grim_root: @grim_root
+      }
+    end
+
+    private
+
+    def execute_audit
+      script_path = File.join(@grim_root, "sh_grim", "security.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "audit", chdir: @grim_root)
+        {
+          command: "audit",
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Security script not found", module: "security" }
+      end
+    end
+
+    def execute_scan(*args)
+      path = args.first || "/"
+      script_path = File.join(@grim_root, "sh_grim", "security.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "scan-vulnerabilities", path, chdir: @grim_root)
+        {
+          command: "scan",
+          path: path,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Security script not found", module: "security" }
+      end
+    end
+
+    def execute_encrypt(*args)
+      file = args.first
+      return { error: "File path required", module: "security" } unless file
+
+      script_path = File.join(@grim_root, "sh_grim", "security.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "encrypt", file, chdir: @grim_root)
+        {
+          command: "encrypt",
+          file: file,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Security script not found", module: "security" }
+      end
+    end
+
+    def execute_decrypt(*args)
+      file = args.first
+      return { error: "File path required", module: "security" } unless file
+
+      script_path = File.join(@grim_root, "sh_grim", "security.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "decrypt", file, chdir: @grim_root)
+        {
+          command: "decrypt",
+          file: file,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Security script not found", module: "security" }
+      end
+    end
+
+    def execute_quarantine(*args)
+      file = args.first
+      return { error: "File path required", module: "security" } unless file
+
+      script_path = File.join(@grim_root, "sh_grim", "quarantine.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "isolate", file, chdir: @grim_root)
+        {
+          command: "quarantine",
+          file: file,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Quarantine script not found", module: "security" }
+      end
+    end
+
+    def execute_threat(*args)
+      script_path = File.join(@grim_root, "scythe", "scythe.py")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3("python3", script_path, "threat", *args, chdir: @grim_root)
+        {
+          command: "threat",
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Scythe script not found", module: "security" }
+      end
+    end
+
+    def execute_generic(command, *args)
+      script_path = File.join(@grim_root, "sh_grim", "#{command}.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, *args, chdir: @grim_root)
+        {
+          command: command,
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "security"
+        }
+      else
+        { error: "Security script not found: #{command}.sh", module: "security" }
+      end
+    end
+  end
+end 

data/lib/grim_reaper/shell_module.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module GrimReaper
+  # Shell module wrapper for sh_grim operations
+  class ShellModule
+    attr_reader :config, :grim_root
+
+    def initialize(config, grim_root)
+      @config = config
+      @grim_root = grim_root
+    end
+
+    def execute(command, *args)
+      case command
+      when "backup"
+        execute_backup(*args)
+      when "restore"
+        execute_restore(*args)
+      when "monitor"
+        execute_monitor(*args)
+      when "scan"
+        execute_scan(*args)
+      when "security"
+        execute_security(*args)
+      else
+        execute_generic(command, *args)
+      end
+    end
+
+    def status
+      {
+        status: "ready",
+        module: "shell",
+        available_commands: %w[backup restore monitor scan security],
+        grim_root: @grim_root
+      }
+    end
+
+    private
+
+    def execute_backup(*args)
+      path = args.first || "/"
+      script_path = File.join(@grim_root, "sh_grim", "backup.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "create", path, chdir: @grim_root)
+        {
+          command: "backup",
+          path: path,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "shell"
+        }
+      else
+        { error: "Backup script not found", module: "shell" }
+      end
+    end
+
+    def execute_restore(*args)
+      backup = args.first
+      return { error: "Backup path required", module: "shell" } unless backup
+
+      script_path = File.join(@grim_root, "sh_grim", "restore.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "recover", backup, chdir: @grim_root)
+        {
+          command: "restore",
+          backup: backup,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "shell"
+        }
+      else
+        { error: "Restore script not found", module: "shell" }
+      end
+    end
+
+    def execute_monitor(*args)
+      path = args.first || "/"
+      script_path = File.join(@grim_root, "sh_grim", "monitor.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "start", path, chdir: @grim_root)
+        {
+          command: "monitor",
+          path: path,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "shell"
+        }
+      else
+        { error: "Monitor script not found", module: "shell" }
+      end
+    end
+
+    def execute_scan(*args)
+      path = args.first || "/"
+      script_path = File.join(@grim_root, "sh_grim", "scan.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "full", path, chdir: @grim_root)
+        {
+          command: "scan",
+          path: path,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "shell"
+        }
+      else
+        { error: "Scan script not found", module: "shell" }
+      end
+    end
+
+    def execute_security(*args)
+      script_path = File.join(@grim_root, "sh_grim", "security.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, "audit", chdir: @grim_root)
+        {
+          command: "security",
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "shell"
+        }
+      else
+        { error: "Security script not found", module: "shell" }
+      end
+    end
+
+    def execute_generic(command, *args)
+      script_path = File.join(@grim_root, "sh_grim", "#{command}.sh")
+      
+      if File.exist?(script_path)
+        stdout, stderr, status = Open3.capture3(script_path, *args, chdir: @grim_root)
+        {
+          command: command,
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success?,
+          module: "shell"
+        }
+      else
+        { error: "Script not found: #{command}.sh", module: "shell" }
+      end
+    end
+  end
+end 

data/lib/grim_reaper/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GrimReaper
+  VERSION = "1.0.29"
+end 

data/lib/grim_reaper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "grim_reaper/version"
+require_relative "grim_reaper/core"
+require_relative "grim_reaper/shell_module"
+require_relative "grim_reaper/python_module"
+require_relative "grim_reaper/go_module"
+require_relative "grim_reaper/security_module"
+require_relative "grim_reaper/installer"
+
+# Grim Reaper - The Ultimate Backup, Monitoring, and Security System
+# Ruby Wrapper for all Grim Reaper modules
+module GrimReaper
+  class Error < StandardError; end
+  
+  # Main entry point for the gem
+  def self.new(config = {})
+    Core.new(config)
+  end
+  
+  # Quick access methods
+  def self.status
+    Core.new.status
+  end
+  
+  def self.execute(command, *args)
+    Core.new.execute(command, *args)
+  end
+  
+  def self.backup(path)
+    Core.new.execute('backup', path)
+  end
+  
+  def self.monitor(path)
+    Core.new.execute('monitor', path)
+  end
+  
+  def self.security
+    Core.new.execute('security')
+  end
+end