language-operator 0.1.30 → 0.1.35

data/lib/language_operator/agent/executor.rb

@@ -56,21 +56,17 @@ module LanguageOperator
         execute(enriched_instruction)
       end
 
-      # Execute a single task or workflow
+      # Execute a single task
       #
       # @param task [String] The task to execute
-      # @param agent_definition [LanguageOperator::Dsl::AgentDefinition, nil] Optional agent definition with workflow
+      # @param agent_definition [LanguageOperator::Dsl::AgentDefinition, nil] Optional agent definition (unused in DSL v1)
       # @return [String] The result
-      # rubocop:disable Metrics/BlockLength
       def execute(task, agent_definition: nil)
         with_span('agent.execute_goal', attributes: {
                     'agent.goal_description' => task[0...500]
                   }) do
           @iteration_count += 1
 
-          # Route to workflow execution if agent has a workflow defined
-          return execute_workflow(agent_definition) if agent_definition&.workflow
-
           # Standard instruction-based execution
           logger.info('Starting iteration',
                       iteration: @iteration_count,
@@ -90,7 +86,7 @@ module LanguageOperator
             )
           end
 
-          logger.info('🤖 LLM request')
+          logger.info('LLM request')
           result = logger.timed('LLM response received') do
             @agent.send_message(task)
           end
@@ -110,12 +106,14 @@ module LanguageOperator
               tokens: metrics[:totalTokens]
             )
           end
-          logger.info('✓ Iteration completed',
-                      iteration: @iteration_count,
-                      response_length: result_text.length,
-                      total_tokens: metrics[:totalTokens],
-                      estimated_cost: "$#{metrics[:estimatedCost]}")
-          logger.debug('Response preview', response: result_text[0..200])
+
+          # Log the actual LLM response content (strip [THINK] blocks)
+          cleaned_response = result_text.gsub(%r{\[THINK\].*?\[/THINK\]}m, '').strip
+          response_preview = cleaned_response.length > 500 ? "#{cleaned_response[0..500]}..." : cleaned_response
+          puts "\e[1;35m·\e[0m #{response_preview}" unless response_preview.empty?
+
+          # Log iteration completion with green dot
+          puts "\e[1;32m·\e[0m Iteration completed (iteration=#{@iteration_count}, response_length=#{result_text.length}, total_tokens=#{metrics[:totalTokens]}, estimated_cost=$#{metrics[:estimatedCost]})"
 
           result
         rescue StandardError => e
@@ -130,7 +128,7 @@ module LanguageOperator
       def run_loop
         start_time = Time.now
 
-        logger.info('▶ Starting execution')
+        logger.info('Starting execution')
         logger.info('Configuration',
                     workspace: @agent.workspace_path,
                     mcp_servers: @agent.servers_info.length,
@@ -152,7 +150,9 @@ module LanguageOperator
                        ENV['AGENT_INSTRUCTIONS'] ||
                        'Monitor workspace and respond to changes'
 
-        logger.info('Instructions', instructions: instructions[0..200])
+        # Log instructions with bold white formatting
+        instructions_preview = instructions[0..200]
+        puts "\e[1;37m·\e[0m \e[1;37m#{instructions_preview}\e[0m"
         logger.info('Starting autonomous execution loop')
 
         loop do
@@ -188,7 +188,7 @@ module LanguageOperator
         # Log execution summary
         total_duration = Time.now - start_time
         metrics = @metrics_tracker.cumulative_stats
-        logger.info('✅ Execution complete',
+        logger.info('Execution complete',
                     iterations: @iteration_count,
                     duration_s: total_duration.round(2),
                     total_requests: metrics[:requestCount],
@@ -203,84 +203,6 @@ module LanguageOperator
                     reason: 'Hit max_iterations limit')
       end
 
-      # Execute a workflow-based agent
-      #
-      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
-      # @return [RubyLLM::Message] The final response
-      def execute_workflow(agent_def)
-        start_time = Time.now
-
-        logger.info("▶ Starting workflow execution: #{agent_def.name}")
-
-        # Log persona if defined
-        logger.info("👤 Loading persona: #{agent_def.persona}") if agent_def.persona
-
-        # Build orchestration prompt from agent definition
-        prompt = build_workflow_prompt(agent_def)
-        logger.debug('Workflow prompt', prompt: prompt[0..300])
-
-        # Register workflow steps as tools (placeholder - will implement after tool converter)
-        # For now, just execute with instructions
-        result = logger.timed('🤖 LLM request') do
-          @agent.send_message(prompt)
-        end
-
-        # Record metrics
-        model_id = @agent.config.dig('llm', 'model')
-        @metrics_tracker.record_request(result, model_id) if model_id
-
-        # Write output if configured
-        write_output(agent_def, result) if agent_def.output_config && result
-
-        # Log execution summary
-        total_duration = Time.now - start_time
-        metrics = @metrics_tracker.cumulative_stats
-        logger.info('✅ Workflow execution completed',
-                    duration_s: total_duration.round(2),
-                    total_tokens: metrics[:totalTokens],
-                    estimated_cost: "$#{metrics[:estimatedCost]}")
-        result
-      rescue StandardError => e
-        logger.error('❌ Workflow execution failed', error: e.message)
-        handle_error(e)
-      end
-
-      # Build orchestration prompt from agent definition
-      #
-      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
-      # @return [String] The prompt
-      def build_workflow_prompt(agent_def)
-        prompt = "# Task: #{agent_def.description}\n\n"
-
-        if agent_def.objectives&.any?
-          prompt += "## Objectives:\n"
-          agent_def.objectives.each { |obj| prompt += "- #{obj}\n" }
-          prompt += "\n"
-        end
-
-        if agent_def.workflow&.steps&.any?
-          prompt += "## Workflow Steps:\n"
-          agent_def.workflow.step_order.each do |step_name|
-            step = agent_def.workflow.steps[step_name]
-            prompt += step_name.to_s.tr('_', ' ').capitalize.to_s
-            prompt += " (using tool: #{step.tool_name})" if step.tool_name
-            prompt += " - depends on: #{step.dependencies.join(', ')}" if step.dependencies&.any?
-            prompt += "\n"
-          end
-          prompt += "\n"
-        end
-
-        if agent_def.constraints
-          prompt += "## Constraints:\n"
-          prompt += "- Maximum iterations: #{agent_def.constraints[:max_iterations]}\n" if agent_def.constraints[:max_iterations]
-          prompt += "- Timeout: #{agent_def.constraints[:timeout]}\n" if agent_def.constraints[:timeout]
-          prompt += "\n"
-        end
-
-        prompt += 'Please complete this task following the workflow steps.'
-        prompt
-      end
-
       # Write output to configured destinations
       #
       # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
@@ -302,10 +224,10 @@ module LanguageOperator
             fallback_path = File.join(@agent.workspace_path, 'output.txt')
             begin
               File.write(fallback_path, content)
-              logger.warn("⚠️  Could not write to #{workspace_path}, wrote to output.txt instead")
+              logger.warn("Could not write to #{workspace_path}, wrote to output.txt instead")
             rescue StandardError => e2
-              logger.warn("⚠️  Could not write output to workspace: #{e2.message}")
-              logger.info("📄 Output (first 500 chars): #{content[0..500]}")
+              logger.warn("Could not write output to workspace: #{e2.message}")
+              logger.info("Output (first 500 chars): #{content[0..500]}")
             end
           end
         end

data/lib/language_operator/agent/safety/ast_validator.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require 'parser/current'
+require 'prism'
 
 module LanguageOperator
   module Agent
     module Safety
       # Validates synthesized Ruby code for security before execution
       # Performs static analysis to detect dangerous method calls
+      #
+      # Supports DSL v1 (task/main model) and validates both neural and symbolic
+      # task implementations to ensure they use only safe Ruby subset.
       class ASTValidator
         # Gems that are safe to require (allowlist)
         # These are required for agent execution and are safe
@@ -36,10 +39,10 @@ module LanguageOperator
           STDIN STDOUT STDERR
         ].freeze
 
-        # Safe DSL methods that are allowed in agent definitions
+        # Safe DSL methods that are allowed in agent definitions (DSL v1)
         SAFE_AGENT_METHODS = %w[
           agent description persona schedule objectives objective
-          workflow step tool params depends_on prompt
+          task main execute_task inputs outputs instructions
           constraints budget max_requests rate_limit content_filter
           output mode webhook as_mcp_server as_chat_endpoint
         ].freeze
@@ -57,6 +60,7 @@ module LanguageOperator
           env_required env_get
           truncate parse_csv
           error success
+          TypeCoercion
         ].freeze
 
         # Safe Ruby built-in methods and classes
@@ -76,7 +80,7 @@ module LanguageOperator
         class SecurityError < StandardError; end
 
         def initialize
-          @parser = Parser::CurrentRuby.new
+          # Prism doesn't require initialization
         end
 
         # Validate code and raise SecurityError if dangerous methods found
@@ -102,62 +106,69 @@ module LanguageOperator
           begin
             ast = parse_code(code, file_path)
           rescue SecurityError => e
-            # Convert SecurityError (which wraps Parser::SyntaxError) to violation
+            # Convert SecurityError (which wraps syntax error) to violation
             return [{ type: :syntax_error, message: e.message }]
           end
 
           return [] if ast.nil?
 
           scan_ast(ast)
-        rescue Parser::SyntaxError => e
+        rescue Prism::ParseError => e
           [{ type: :syntax_error, message: e.message }]
         end
 
         private
 
         def parse_code(code, file_path)
-          buffer = Parser::Source::Buffer.new(file_path)
-          buffer.source = code
-          @parser.parse(buffer)
-        rescue Parser::SyntaxError => e
+          result = Prism.parse(code, filepath: file_path)
+
+          # Prism is forgiving and creates an AST even with some syntax errors
+          # We'll allow parsing to proceed and only raise if there are FATAL errors
+          # that prevent AST creation entirely
+          if result.value.nil?
+            errors = result.errors.map(&:message).join('; ')
+            raise SecurityError, "Syntax error in #{file_path}: #{errors}"
+          end
+
+          result.value
+        rescue Prism::ParseError => e
           raise SecurityError, "Syntax error in #{file_path}: #{e.message}"
         end
 
         def scan_ast(node, violations = [])
           return violations if node.nil?
 
-          case node.type
-          when :send
+          # Prism uses different node types
+          case node
+          when Prism::CallNode
             check_method_call(node, violations)
-          when :const
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
             check_constant(node, violations)
-          when :gvar
+          when Prism::GlobalVariableReadNode, Prism::GlobalVariableWriteNode
             check_global_variable(node, violations)
-          when :xstr
+          when Prism::XStringNode
             # Backtick string execution (e.g., `command`)
             violations << {
               type: :backtick_execution,
-              location: node.location.line,
+              location: node.location.start_line,
               message: 'Backtick command execution is not allowed'
             }
           end
 
           # Recursively scan all child nodes
-          node.children.each do |child|
-            scan_ast(child, violations) if child.is_a?(Parser::AST::Node)
+          node.compact_child_nodes.each do |child|
+            scan_ast(child, violations)
           end
 
           violations
         end
 
         def check_method_call(node, violations)
-          receiver, method_name, *args = node.children
-
-          method_str = method_name.to_s
+          method_str = node.name.to_s
 
           # Special handling for require - check if it's in the allowlist
           if %w[require require_relative].include?(method_str)
-            required_gem = extract_require_argument(args)
+            required_gem = extract_require_argument(node)
 
             # Allow if in the allowlist
             return if required_gem && ALLOWED_REQUIRES.include?(required_gem)
@@ -166,7 +177,7 @@ module LanguageOperator
             violations << {
               type: :dangerous_method,
               method: method_str,
-              location: node.location.line,
+              location: node.location.start_line,
               message: "Dangerous method '#{method_str}' is not allowed"
             }
             return
@@ -177,20 +188,21 @@ module LanguageOperator
             violations << {
               type: :dangerous_method,
               method: method_str,
-              location: node.location.line,
+              location: node.location.start_line,
               message: "Dangerous method '#{method_str}' is not allowed"
             }
           end
 
           # Check for File/Dir/IO operations
-          if receiver && receiver.type == :const
-            const_name = receiver.children[1].to_s
-            if DANGEROUS_CONSTANTS.include?(const_name)
+          receiver = node.receiver
+          if receiver && (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode))
+            const_name = receiver.is_a?(Prism::ConstantReadNode) ? receiver.name.to_s : receiver.name
+            if DANGEROUS_CONSTANTS.include?(const_name.to_s)
               violations << {
                 type: :dangerous_constant,
-                constant: const_name,
+                constant: const_name.to_s,
                 method: method_str,
-                location: node.location.line,
+                location: node.location.start_line,
                 message: "Access to #{const_name}.#{method_str} is not allowed"
               }
             end
@@ -202,14 +214,20 @@ module LanguageOperator
 
           violations << {
             type: :backtick_execution,
-            location: node.location.line,
+            location: node.location.start_line,
             message: 'Backtick command execution is not allowed'
           }
         end
 
         def check_constant(node, violations)
-          _, const_name = node.children
-          const_str = const_name.to_s
+          const_str = if node.is_a?(Prism::ConstantReadNode)
+                        node.name.to_s
+                      elsif node.is_a?(Prism::ConstantPathNode)
+                        # For paths like Foo::Bar, get the last part
+                        node.name.to_s
+                      else
+                        return
+                      end
 
           # Check for dangerous constants being accessed directly
           return unless DANGEROUS_CONSTANTS.include?(const_str)
@@ -217,13 +235,13 @@ module LanguageOperator
           violations << {
             type: :dangerous_constant_access,
             constant: const_str,
-            location: node.location.line,
+            location: node.location.start_line,
             message: "Direct access to #{const_str} constant is not allowed"
           }
         end
 
         def check_global_variable(node, violations)
-          var_name = node.children[0].to_s
+          var_name = node.name.to_s
 
           # Block access to dangerous global variables
           dangerous_globals = %w[$0 $PROGRAM_NAME $LOAD_PATH $: $LOADED_FEATURES $"]
@@ -233,21 +251,22 @@ module LanguageOperator
           violations << {
             type: :dangerous_global,
             variable: var_name,
-            location: node.location.line,
+            location: node.location.start_line,
             message: "Access to global variable #{var_name} is not allowed"
           }
         end
 
-        def extract_require_argument(args)
-          # args is an array of AST nodes representing the arguments to require
-          # We're looking for a string literal like 'language_operator' or "language_operator"
-          return nil if args.empty?
+        def extract_require_argument(node)
+          # node is a CallNode for require/require_relative
+          # We're looking for a string literal argument like 'language_operator' or "language_operator"
+          args = node.arguments
+          return nil unless args&.arguments&.any?
 
-          arg_node = args.first
+          arg_node = args.arguments.first
           return nil unless arg_node
 
-          # Check if it's a string literal (:str node)
-          return arg_node.children[0] if arg_node.type == :str
+          # Check if it's a string literal (StringNode)
+          return arg_node.unescaped if arg_node.is_a?(Prism::StringNode)
 
           # If it's not a string literal (e.g., dynamic require), we can't verify it
           nil
@@ -262,7 +281,7 @@ module LanguageOperator
 
           footer = "\n\nSynthesized code must only use safe DSL methods and approved helpers."
           footer += "\nSafe methods include: #{SAFE_AGENT_METHODS.join(', ')}, #{SAFE_TOOL_METHODS.join(', ')}"
-          footer += "\nSafe helpers include: HTTP.*, Shell.run, validate_*, env_*"
+          footer += "\nSafe helpers include: HTTP.*, Shell.run, validate_*, env_*, TypeCoercion.coerce"
 
           header + violation_messages.join("\n") + footer
         end

data/lib/language_operator/agent/safety/safe_executor.rb

@@ -34,10 +34,32 @@ module LanguageOperator
           # Step 2: Execute in sandboxed context
           sandbox = SandboxProxy.new(@context, self)
 
-          # Step 3: Execute using instance_eval
+          # Step 3: Prepend safe constant definitions to the code
+          # This makes Ruby type constants available in the evaluated scope
+          safe_constants_code = <<~RUBY
+            Numeric = ::Numeric
+            Integer = ::Integer
+            Float = ::Float
+            String = ::String
+            Array = ::Array
+            Hash = ::Hash
+            TrueClass = ::TrueClass
+            FalseClass = ::FalseClass
+            Time = ::Time
+            Date = ::Date
+          RUBY
+
+          # Step 4: Execute using instance_eval with safe constants prepended
           # Note: We still use instance_eval but with validated code
           # and wrapped context
-          sandbox.instance_eval(code, file_path)
+          #
+          # The string interpolation below evaluates to:
+          #   sandbox.instance_eval("Numeric = ::Numeric\nInteger = ::Integer\nFloat = ::Float\n
+          #     String = ::String\nArray = ::Array\nHash = ::Hash\nTrueClass = ::TrueClass\n
+          #     FalseClass = ::FalseClass\nTime = ::Time\nDate = ::Date\n<user code>", __FILE__, __LINE__)
+          # rubocop:disable Style/DocumentDynamicEvalDefinition
+          sandbox.instance_eval("#{safe_constants_code}\n#{code}", __FILE__, __LINE__)
+          # rubocop:enable Style/DocumentDynamicEvalDefinition
         rescue ASTValidator::SecurityError => e
           # Re-raise validation errors as executor errors for clarity
           raise SecurityError, "Code validation failed: #{e.message}"
@@ -69,6 +91,18 @@ module LanguageOperator
             # Log the call
             @__executor__.log_call(@__context__, method_name, args)
 
+            # Special handling for require - allow only 'language_operator'
+            if %i[require require_relative].include?(method_name)
+              required_gem = args.first.to_s
+              return ::Kernel.require(required_gem) if required_gem == 'language_operator'
+
+              # Allow require 'language_operator'
+
+              ::Kernel.raise ::LanguageOperator::Agent::Safety::SafeExecutor::SecurityError,
+                             "Require '#{required_gem}' is not allowed. Only 'require \"language_operator\"' is permitted."
+
+            end
+
             # Check if method is safe
             unless safe_method?(method_name)
               ::Kernel.raise ::LanguageOperator::Agent::Safety::SafeExecutor::SecurityError,
@@ -92,6 +126,9 @@ module LanguageOperator
               return ::LanguageOperator::Dsl::Shell
             end
 
+            # Ruby type constants are now injected at eval time (see SafeExecutor#eval)
+            # but keep this as fallback for dynamic constant access
+
             # Otherwise delegate to the context's module
             @__context__.class.const_get(name)
           rescue ::NameError

data/lib/language_operator/agent/scheduler.rb

@@ -84,6 +84,51 @@ module LanguageOperator
         @rufus_scheduler.join
       end
 
+      # Start the scheduler with a main block (DSL v1)
+      #
+      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition with main block
+      # @return [void]
+      def start_with_main(agent_def)
+        logger.info('Agent starting in scheduled mode with main block',
+                    agent_name: agent_def.name,
+                    task_count: agent_def.tasks.size)
+        logger.info("Workspace: #{@agent.workspace_path}")
+        logger.info("Connected to #{@agent.servers_info.length} MCP server(s)")
+
+        # Extract schedule from agent definition or use default
+        cron_schedule = agent_def.schedule&.cron || '0 6 * * *'
+
+        logger.info('Scheduling main block execution', cron: cron_schedule, agent: agent_def.name)
+
+        # Create task executor with constraints config
+        require_relative 'task_executor'
+        config = build_executor_config(agent_def)
+        task_executor = TaskExecutor.new(@agent, agent_def.tasks, config)
+
+        @rufus_scheduler.cron(cron_schedule) do
+          with_span('agent.scheduler.execute', attributes: {
+                      'scheduler.cron_expression' => cron_schedule,
+                      'agent.name' => agent_def.name,
+                      'scheduler.task_type' => 'main_block'
+                    }) do
+            logger.timed('Scheduled main block execution') do
+              logger.info('Executing scheduled main block', agent: agent_def.name)
+
+              # Get inputs from environment or default to empty hash
+              inputs = {}
+
+              # Execute main block
+              result = agent_def.main.call(inputs, task_executor)
+
+              logger.info('Main block completed', result: result)
+            end
+          end
+        end
+
+        logger.info('Scheduler started, waiting for scheduled tasks')
+        @rufus_scheduler.join
+      end
+
       # Stop the scheduler
       #
       # @return [void]
@@ -178,6 +223,21 @@ module LanguageOperator
 
         logger.info('Scheduled: Daily at 6:00 AM')
       end
+
+      # Build executor configuration from agent definition constraints
+      #
+      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
+      # @return [Hash] Executor configuration
+      def build_executor_config(agent_def)
+        config = {}
+
+        if agent_def.constraints
+          config[:timeout] = agent_def.constraints[:timeout] if agent_def.constraints[:timeout]
+          config[:max_retries] = agent_def.constraints[:max_retries] if agent_def.constraints[:max_retries]
+        end
+
+        config
+      end
     end
   end
 end