ai_sentinel 0.1.0

data/lib/ai_sentinel/runner.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module AiSentinel
+  class Runner
+    ACTION_MAP = {
+      http_get: Actions::HttpGet,
+      http_post: Actions::HttpPost,
+      ai_prompt: Actions::AiPrompt,
+      shell_command: Actions::ShellCommand
+    }.freeze
+
+    attr_reader :workflow, :configuration
+
+    def initialize(workflow:, configuration:)
+      @workflow = workflow
+      @configuration = configuration
+    end
+
+    def execute
+      execution_id = Persistence::ExecutionLog.create(workflow_name: workflow.name)
+      context = Context.new(workflow_name: workflow.name, execution_id: execution_id)
+
+      AiSentinel.logger.info("Starting workflow '#{workflow.name}'")
+
+      workflow.steps.each do |step|
+        execute_step(step, context)
+      end
+
+      Persistence::ExecutionLog.complete(execution_id)
+      AiSentinel.logger.info("Workflow '#{workflow.name}' completed successfully")
+      context
+    rescue StandardError => e
+      Persistence::ExecutionLog.fail(execution_id, e.message)
+      AiSentinel.logger.error("Workflow '#{workflow.name}' failed: #{e.message}")
+      raise
+    end
+
+    private
+
+    def execute_step(step, context)
+      if step.skip?(context)
+        AiSentinel.logger.info("  Skipping step '#{step.name}' (condition not met)")
+        return
+      end
+
+      AiSentinel.logger.info("  Running step '#{step.name}' (#{step.action})")
+      started_at = Time.now
+      result = run_action(step, context)
+      context.set(step.name, result)
+
+      log_step_result(context, step, 'completed', started_at, result_data: result)
+      AiSentinel.logger.info("  Step '#{step.name}' completed")
+    rescue StandardError => e
+      log_step_result(context, step, 'failed', started_at || Time.now, error_message: e.message)
+      raise
+    end
+
+    def run_action(step, context)
+      action_class = ACTION_MAP[step.action]
+      raise Error, "Unknown action: #{step.action}" unless action_class
+
+      action_class.new(step: step, context: context, configuration: configuration).call
+    end
+
+    def log_step_result(context, step, status, started_at, result_data: nil, error_message: nil)
+      Persistence::ExecutionLog.log_step(
+        execution_id: context.execution_id,
+        step_name: step.name,
+        action: step.action,
+        status: status,
+        result_data: result_data,
+        error_message: error_message,
+        started_at: started_at
+      )
+    end
+  end
+end

data/lib/ai_sentinel/scheduler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'rufus-scheduler'
+
+module AiSentinel
+  class Scheduler
+    attr_reader :registry, :configuration, :rufus
+
+    def initialize(registry, configuration)
+      @registry = registry
+      @configuration = configuration
+      @rufus = Rufus::Scheduler.new
+    end
+
+    def start(daemonize: false)
+      register_workflows
+
+      if daemonize
+        AiSentinel.logger.info("AiSentinel started in background (#{registry.size} workflow(s))")
+      else
+        AiSentinel.logger.info("AiSentinel started (#{registry.size} workflow(s)). Press Ctrl+C to stop.")
+        trap('INT') { Thread.new { stop } }
+        trap('TERM') { Thread.new { stop } }
+        @rufus.join
+        AiSentinel.logger.info('AiSentinel stopped')
+      end
+    end
+
+    def stop
+      @rufus.shutdown
+    end
+
+    def trigger(workflow_name)
+      workflow = registry[workflow_name.to_s] || registry[workflow_name.to_sym]
+      raise Error, "Unknown workflow: #{workflow_name}" unless workflow
+
+      runner = Runner.new(workflow: workflow, configuration: configuration)
+      runner.execute
+    end
+
+    private
+
+    def register_workflows
+      registry.each do |name, workflow|
+        @rufus.cron(workflow.schedule_expression) do
+          runner = Runner.new(workflow: workflow, configuration: configuration)
+          runner.execute
+        rescue StandardError => e
+          AiSentinel.logger.error("Workflow '#{name}' failed: #{e.message}")
+        end
+
+        AiSentinel.logger.info("Registered workflow '#{name}' with schedule '#{workflow.schedule_expression}'")
+      end
+    end
+  end
+end

data/lib/ai_sentinel/step.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AiSentinel
+  class Step
+    attr_reader :name, :action, :params, :condition
+
+    def initialize(name:, action:, condition: nil, **params)
+      @name = name.to_sym
+      @action = action.to_sym
+      @params = params
+      @condition = condition
+    end
+
+    def skip?(context)
+      return false if condition.nil?
+
+      if condition.respond_to?(:call)
+        !condition.call(context)
+      else
+        !ConditionEvaluator.evaluate(condition.to_s, context)
+      end
+    end
+  end
+end

data/lib/ai_sentinel/tool_executor.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require 'timeout'
+
+module AiSentinel
+  class ToolExecutor
+    SUBSHELL_PATTERN = /\$\(|`/
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_MAX_OUTPUT_BYTES = 10_240
+    DEFAULT_MAX_TOOL_ROUNDS = 10
+
+    attr_reader :tools, :configuration
+
+    def initialize(tools:, configuration:)
+      @tools = tools.to_h { |t| [t.name, t] }
+      @configuration = configuration
+    end
+
+    def tool_definitions_for(provider)
+      @tools.values.map do |tool|
+        case provider
+        when :anthropic then tool.to_anthropic_schema
+        when :openai then tool.to_openai_schema
+        else raise Error, "Unknown provider for tool schema: #{provider}"
+        end
+      end
+    end
+
+    def execute(tool_name, input)
+      tool = @tools[tool_name]
+      raise Error, "Unknown tool: #{tool_name}" unless tool
+
+      case tool_name
+      when 'shell_command'
+        execute_shell_command(input)
+      else
+        tool.execute(input)
+      end
+    end
+
+    def max_tool_rounds
+      configuration.respond_to?(:max_tool_rounds) ? configuration.max_tool_rounds : DEFAULT_MAX_TOOL_ROUNDS
+    end
+
+    private
+
+    def execute_shell_command(input)
+      command = input['command'] || input[:command]
+      raise Error, 'Missing required parameter: command' unless command
+      raise Error, 'Command must be a non-empty string' if command.to_s.strip.empty?
+
+      validate_command!(command)
+
+      timeout = tool_timeout
+      max_bytes = max_output_bytes
+
+      stdout, stderr, status = run_with_timeout(command, timeout)
+
+      stdout = truncate_output(stdout, max_bytes)
+      stderr = truncate_output(stderr, max_bytes)
+
+      JSON.generate(stdout: stdout, stderr: stderr, exit_code: status.exitstatus)
+    rescue Timeout::Error
+      JSON.generate(stdout: '', stderr: "Command timed out after #{timeout}s", exit_code: -1)
+    end
+
+    def validate_command!(command)
+      validate_no_subshells!(command)
+      binaries = extract_binaries(command)
+      validate_allowlist!(binaries)
+    end
+
+    def validate_no_subshells!(command)
+      return unless command.match?(SUBSHELL_PATTERN)
+
+      raise Error, "Command contains subshell execution ($() or backticks) which is not allowed: #{command}"
+    end
+
+    def extract_binaries(command)
+      segments = split_on_operators(command)
+
+      segments.map do |segment|
+        segment = segment.strip
+
+        segment = segment.sub(/\A\s*(?:\w+=\S*\s+)*/, '')
+
+        tokens = Shellwords.split(segment)
+        next nil if tokens.empty?
+
+        binary = tokens.first
+        File.basename(binary)
+      rescue ArgumentError
+        raise Error, "Malformed command segment: #{segment}"
+      end.compact
+    end
+
+    def split_on_operators(command)
+      segments = []
+      current = +''
+      chars = command.chars
+      i = 0
+      quote = nil
+
+      while i < chars.length
+        char = chars[i]
+        quote = toggle_quote(char, quote) if quote_boundary?(char, quote)
+
+        if !quote && (skip = operator_length(chars, i))
+          segments << current
+          current = +''
+          i += skip
+        else
+          current << char
+          i += 1
+        end
+      end
+
+      segments << current unless current.strip.empty?
+      segments
+    end
+
+    def quote_boundary?(char, quote)
+      ["'", '"'].include?(char) && (quote.nil? || quote == char)
+    end
+
+    def toggle_quote(char, quote)
+      quote == char ? nil : char
+    end
+
+    def operator_length(chars, index)
+      two_char = "#{chars[index]}#{chars[index + 1]}"
+      return 2 if ['&&', '||'].include?(two_char)
+      return 1 if [';', '|'].include?(chars[index])
+
+      nil
+    end
+
+    def validate_allowlist!(binaries)
+      allowed = allowed_commands
+      return if allowed.empty?
+
+      binaries.each do |binary|
+        next if allowed.include?(binary)
+
+        raise Error,
+              "Command '#{binary}' is not in the allowed commands list. " \
+              "Allowed: #{allowed.join(', ')}"
+      end
+    end
+
+    def allowed_commands
+      safety = configuration.tool_safety
+      return [] unless safety
+
+      safety[:allowed_commands] || safety['allowed_commands'] || []
+    end
+
+    def tool_timeout
+      safety = configuration.tool_safety
+      return DEFAULT_TIMEOUT unless safety
+
+      safety[:tool_timeout] || safety['tool_timeout'] || DEFAULT_TIMEOUT
+    end
+
+    def max_output_bytes
+      safety = configuration.tool_safety
+      return DEFAULT_MAX_OUTPUT_BYTES unless safety
+
+      safety[:max_output_bytes] || safety['max_output_bytes'] || DEFAULT_MAX_OUTPUT_BYTES
+    end
+
+    def working_directory
+      safety = configuration.tool_safety
+      return nil unless safety
+
+      dir = safety[:working_directory] || safety['working_directory']
+      dir ? File.expand_path(dir) : nil
+    end
+
+    def run_with_timeout(command, timeout)
+      opts = {}
+      dir = working_directory
+      opts[:chdir] = dir if dir
+
+      Timeout.timeout(timeout) do
+        Open3.capture3(command, **opts)
+      end
+    end
+
+    def truncate_output(output, max_bytes)
+      return output if output.bytesize <= max_bytes
+
+      truncated = output.byteslice(0, max_bytes)
+      "#{truncated}\n... [truncated at #{max_bytes} bytes]"
+    end
+  end
+end

data/lib/ai_sentinel/tools/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module AiSentinel
+  module Tools
+    REGISTRY = {}.freeze
+
+    class Base
+      def name
+        raise NotImplementedError, "#{self.class}#name must be implemented"
+      end
+
+      def description
+        raise NotImplementedError, "#{self.class}#description must be implemented"
+      end
+
+      def input_schema
+        raise NotImplementedError, "#{self.class}#input_schema must be implemented"
+      end
+
+      def execute(input)
+        raise NotImplementedError, "#{self.class}#execute must be implemented"
+      end
+
+      def to_anthropic_schema
+        {
+          name: name,
+          description: description,
+          input_schema: input_schema
+        }
+      end
+
+      def to_openai_schema
+        {
+          type: 'function',
+          function: {
+            name: name,
+            description: description,
+            parameters: input_schema
+          }
+        }
+      end
+    end
+  end
+end

data/lib/ai_sentinel/tools/shell_command.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'timeout'
+
+module AiSentinel
+  module Tools
+    class ShellCommand < Base
+      def name
+        'shell_command'
+      end
+
+      def description
+        'Execute a shell command on the local machine. Returns stdout, stderr, and the exit code. ' \
+          'Use this to run CLI tools, inspect files, manage processes, or perform any system operation.'
+      end
+
+      def input_schema
+        {
+          type: 'object',
+          properties: {
+            command: {
+              type: 'string',
+              description: 'The shell command to execute (e.g. "ls -la", "git status", "cat file.txt")'
+            }
+          },
+          required: ['command']
+        }
+      end
+
+      def execute(input)
+        command = input['command'] || input[:command]
+        raise Error, 'Missing required parameter: command' unless command
+        raise Error, 'Command must be a non-empty string' if command.strip.empty?
+
+        { stdout: '', stderr: '', exit_code: -1 }
+      end
+    end
+  end
+end

data/lib/ai_sentinel/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AiSentinel
+  VERSION = '0.1.0'
+end

data/lib/ai_sentinel/workflow.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AiSentinel
+  class Workflow
+    attr_reader :name, :schedule_expression, :steps
+
+    def initialize(name:, schedule_expression:, steps: [])
+      @name = name
+      @schedule_expression = schedule_expression
+      @steps = steps
+    end
+
+    def add_step(step)
+      @steps << step
+    end
+  end
+end

data/lib/ai_sentinel.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'dotenv/load'
+require 'logger'
+
+require_relative 'ai_sentinel/version'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'cli' => 'CLI',
+  'dsl' => 'DSL'
+)
+loader.ignore("#{__dir__}/ai_sentinel/version.rb")
+loader.setup
+
+module AiSentinel
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      resolve_api_key
+      configuration
+    end
+
+    def registry
+      @registry ||= {}
+    end
+
+    def start(daemonize: false)
+      resolve_api_key
+      configuration.validate!
+      Persistence::Database.setup(configuration.database_path)
+      scheduler = Scheduler.new(registry, configuration)
+      scheduler.start(daemonize: daemonize)
+      scheduler
+    end
+
+    def reset!
+      @configuration = nil
+      @registry = {}
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def resolve_api_key
+      configuration.api_key ||= ENV.fetch(configuration.env_key_name, nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: ai_sentinel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mario Celi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Schedule AI-driven tasks to run at specified times, process results through
+  LLMs, and take conditional actions based on the output. Designed to be lightweight
+  and self-hostable.
+email:
+- mcelicalderon@gmail.com
+executables:
+- ai_sentinel
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ai_sentinel.yml.example
+- exe/ai_sentinel
+- lib/ai_sentinel.rb
+- lib/ai_sentinel/actions/ai_prompt.rb
+- lib/ai_sentinel/actions/base.rb
+- lib/ai_sentinel/actions/http_get.rb
+- lib/ai_sentinel/actions/http_post.rb
+- lib/ai_sentinel/actions/shell_command.rb
+- lib/ai_sentinel/cli.rb
+- lib/ai_sentinel/cli/context_display.rb
+- lib/ai_sentinel/cli/helpers.rb
+- lib/ai_sentinel/cli/prompt_change_handler.rb
+- lib/ai_sentinel/condition_evaluator.rb
+- lib/ai_sentinel/config_loader.rb
+- lib/ai_sentinel/configuration.rb
+- lib/ai_sentinel/configuration_error.rb
+- lib/ai_sentinel/context.rb
+- lib/ai_sentinel/context_compactor.rb
+- lib/ai_sentinel/dsl.rb
+- lib/ai_sentinel/persistence/database.rb
+- lib/ai_sentinel/persistence/execution_log.rb
+- lib/ai_sentinel/prompt_change_detector.rb
+- lib/ai_sentinel/providers/anthropic.rb
+- lib/ai_sentinel/providers/base.rb
+- lib/ai_sentinel/providers/openai.rb
+- lib/ai_sentinel/runner.rb
+- lib/ai_sentinel/scheduler.rb
+- lib/ai_sentinel/step.rb
+- lib/ai_sentinel/tool_executor.rb
+- lib/ai_sentinel/tools/base.rb
+- lib/ai_sentinel/tools/shell_command.rb
+- lib/ai_sentinel/version.rb
+- lib/ai_sentinel/workflow.rb
+homepage: https://github.com/mcelicalderon/ai_sentinel
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mcelicalderon/ai_sentinel
+  source_code_uri: https://github.com/mcelicalderon/ai_sentinel
+  changelog_uri: https://github.com/mcelicalderon/ai_sentinel/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Lightweight AI task scheduler with conditional actions
+test_files: []