language-operator 0.1.44 → 0.1.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 588de63b620795a41863a1fe516368c01ea002290a87c49d3632839b0d8b190b
-  data.tar.gz: d16c8648276ddfd5a4d4bced8f5bc3a263a51b8250f195858c5c459450785292
+  metadata.gz: 7515f5597eb485e7053423816336675f70bb8967e96072a68d94dd0a613cfb53
+  data.tar.gz: 896319f5aecbc4b8ff5bb67717e48beec8a9aa72dd4337af6f0588f8794c9a35
 SHA512:
-  metadata.gz: 6e58ec25b437ee27932f0067e7404fc7fc44e8597e44771c6338fd5886cef30792c61fd01fd595db22bf03d40a9c661332807807b67fdfdeb84e4a16c922c6f6
-  data.tar.gz: b84d6129fe0e7464d4ad620d7a82000298f5ec95345e9c451a0996b4fd8f976aa0981599942bbfdc9d0b711543fe8838725960bfcc09bf242e8da22dfaa4a047
+  metadata.gz: 49bf23ff4521a0b827d44b2176512d664af2eb895446114c23aa4fd8d3ab65d1c4bc32da07daf2dda74adbfee3453e41b4dfc5b82c3e4dbfa42431929bb3ac28
+  data.tar.gz: 5c258dad400d7790ccbf967862bf508796730382cf3a85463a3886d0d29ab27415706846ddefbdc6941d927705a118bb5cc5d24fa98d71d7caa55868e8531eed

data/.rubocop.yml

@@ -40,7 +40,6 @@ Metrics/ClassLength:
     - 'lib/language_operator/agent/**/*'
     - 'lib/language_operator/kubernetes/**/*'
     - 'lib/language_operator/dsl/**/*'
-    - 'lib/language_operator/synthesis_test_harness.rb'
 
 Metrics/ModuleLength:
   Max: 150
@@ -112,7 +111,6 @@ Naming/MethodParameterName:
 Naming/PredicateMethod:
   Exclude:
     - 'lib/language_operator/agent/webhook_authenticator.rb'
-    - 'lib/language_operator/synthesis_test_harness.rb'
 
 # Layout
 Layout/LineLength:
@@ -121,4 +119,3 @@ Layout/LineLength:
     - 'spec/**/*'
     - '*.gemspec'
     - 'lib/language_operator/agent/executor.rb'
-    - 'lib/language_operator/synthesis_test_harness.rb'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.44)
+    language-operator (0.1.45)
       faraday (~> 2.0)
       k8s-ruby (~> 0.17)
       mcp (~> 0.4)

data/lib/language_operator/cli/commands/system.rb

@@ -198,7 +198,7 @@ module LanguageOperator
           end
         end
 
-        desc 'synthesize INSTRUCTIONS', 'Synthesize agent code from natural language instructions'
+        desc 'synthesize [INSTRUCTIONS]', 'Synthesize agent code from natural language instructions'
         long_desc <<-DESC
           Synthesize agent code by converting natural language instructions
           into Ruby DSL code without creating an actual agent.
@@ -207,6 +207,9 @@ module LanguageOperator
           agent code. If --model is not specified, the first available model will
           be auto-selected.
 
+          Instructions can be provided either as a command argument or via STDIN.
+          If no argument is provided, the command will read from STDIN.
+
           This command helps you validate your instructions and understand how the
           synthesis engine interprets them. Use --dry-run to see the prompt that
           would be sent to the LLM, or run without it to generate actual code.
@@ -224,6 +227,12 @@ module LanguageOperator
             # Output raw code without formatting (useful for piping to files)
             aictl system synthesize "Monitor logs" --raw > agent.rb
 
+            # Read instructions from STDIN
+            cat instructions.txt | aictl system synthesize > agent.rb
+
+            # Read from STDIN with pipe
+            echo "Monitor GitHub issues" | aictl system synthesize --raw
+
             # Specify custom agent name and tools
             aictl system synthesize "Process webhooks from GitHub" \\
               --agent-name github-processor \\
@@ -236,8 +245,29 @@ module LanguageOperator
         option :model, type: :string, desc: 'Model to use for synthesis (defaults to first available in cluster)'
         option :dry_run, type: :boolean, default: false, desc: 'Show prompt without calling LLM'
         option :raw, type: :boolean, default: false, desc: 'Output only the raw code without formatting'
-        def synthesize(instructions)
+        def synthesize(instructions = nil)
           handle_command_error('synthesize agent') do
+            # Read instructions from STDIN if not provided as argument
+            if instructions.nil? || instructions.strip.empty?
+              if $stdin.tty?
+                Formatters::ProgressFormatter.error('No instructions provided')
+                puts
+                puts 'Provide instructions either as an argument or via STDIN:'
+                puts '  aictl system synthesize "Your instructions here"'
+                puts '  cat instructions.txt | aictl system synthesize'
+                exit 1
+              else
+                instructions = $stdin.read.strip
+                if instructions.empty?
+                  Formatters::ProgressFormatter.error('No instructions provided')
+                  puts
+                  puts 'Provide instructions either as an argument or via STDIN:'
+                  puts '  aictl system synthesize "Your instructions here"'
+                  puts '  cat instructions.txt | aictl system synthesize'
+                  exit 1
+                end
+              end
+            end
             # Select model to use for synthesis
             selected_model = select_synthesis_model
 
@@ -306,6 +336,137 @@ module LanguageOperator
           end
         end
 
+        desc 'exec [AGENT_FILE]', 'Execute an agent file in a test pod on the cluster'
+        long_desc <<-DESC
+          Deploy and execute an agent file in a temporary test pod on the Kubernetes cluster.
+
+          This command creates a ConfigMap with the agent code, deploys a test pod,
+          streams the logs until completion, and cleans up all resources.
+
+          The agent code is mounted at /etc/agent/code/agent.rb as expected by the agent runtime.
+
+          Agent code can be provided either as a file path or via STDIN.
+          If no file path is provided, the command will read from STDIN.
+
+          Examples:
+            # Execute a synthesized agent file
+            aictl system exec agent.rb
+
+            # Execute with a custom agent name
+            aictl system exec agent.rb --agent-name my-test
+
+            # Keep the pod after execution for debugging
+            aictl system exec agent.rb --keep-pod
+
+            # Use a different agent image
+            aictl system exec agent.rb --image ghcr.io/language-operator/agent:v0.1.0
+
+            # Read agent code from STDIN
+            cat agent.rb | aictl system exec
+
+            # Pipe synthesized code directly to execution
+            cat agent.txt | aictl system synthesize | aictl system exec
+        DESC
+        option :agent_name, type: :string, default: 'test-agent', desc: 'Name for the test agent pod'
+        option :keep_pod, type: :boolean, default: false, desc: 'Keep the pod after execution (for debugging)'
+        option :image, type: :string, default: 'ghcr.io/language-operator/agent:latest', desc: 'Agent container image'
+        option :timeout, type: :numeric, default: 300, desc: 'Timeout in seconds for agent execution'
+        def exec(agent_file = nil)
+          handle_command_error('exec agent') do
+            # Verify cluster is selected
+            unless ctx.client
+              Formatters::ProgressFormatter.error('No cluster context available')
+              puts
+              puts 'Please configure kubectl with a valid cluster context:'
+              puts '  kubectl config get-contexts'
+              puts '  kubectl config use-context <context-name>'
+              exit 1
+            end
+
+            # Read agent code from file or STDIN
+            agent_code = if agent_file && !agent_file.strip.empty?
+                           # Read from file
+                           unless File.exist?(agent_file)
+                             Formatters::ProgressFormatter.error("Agent file not found: #{agent_file}")
+                             exit 1
+                           end
+                           File.read(agent_file)
+                         elsif $stdin.tty?
+                           # Read from STDIN
+                           Formatters::ProgressFormatter.error('No agent code provided')
+                           puts
+                           puts 'Provide agent code either as a file or via STDIN:'
+                           puts '  aictl system exec agent.rb'
+                           puts '  cat agent.rb | aictl system exec'
+                           exit 1
+                         else
+                           code = $stdin.read.strip
+                           if code.empty?
+                             Formatters::ProgressFormatter.error('No agent code provided')
+                             puts
+                             puts 'Provide agent code either as a file or via STDIN:'
+                             puts '  aictl system exec agent.rb'
+                             puts '  cat agent.rb | aictl system exec'
+                             exit 1
+                           end
+                           code
+                         end
+
+            # Generate unique names
+            timestamp = Time.now.to_i
+            configmap_name = "#{options[:agent_name]}-code-#{timestamp}"
+            pod_name = "#{options[:agent_name]}-#{timestamp}"
+
+            begin
+              # Create ConfigMap with agent code
+              Formatters::ProgressFormatter.with_spinner('Creating ConfigMap with agent code') do
+                create_agent_configmap(configmap_name, agent_code)
+              end
+
+              # Create test pod
+              Formatters::ProgressFormatter.with_spinner('Creating test pod') do
+                create_test_pod(pod_name, configmap_name, options[:image])
+              end
+
+              # Wait for pod to be ready or running
+              Formatters::ProgressFormatter.with_spinner('Waiting for pod to start') do
+                wait_for_pod_start(pod_name, timeout: 60)
+              end
+
+              # Stream logs until pod completes
+              stream_pod_logs(pod_name, timeout: options[:timeout])
+
+              # Wait for pod to fully terminate and get final status
+              exit_code = wait_for_pod_termination(pod_name)
+
+              if exit_code&.zero?
+                Formatters::ProgressFormatter.success('Agent completed successfully')
+              elsif exit_code
+                Formatters::ProgressFormatter.error("Agent failed with exit code: #{exit_code}")
+              else
+                Formatters::ProgressFormatter.warn('Unable to determine pod exit status')
+              end
+            ensure
+              # Clean up resources unless --keep-pod
+              puts
+              puts
+              if options[:keep_pod]
+                Formatters::ProgressFormatter.info('Resources kept for debugging:')
+                puts "  Pod: #{pod_name}"
+                puts "  ConfigMap: #{configmap_name}"
+                puts
+                puts "To view logs: kubectl logs -n #{ctx.namespace} #{pod_name}"
+                puts "To delete:    kubectl delete pod,configmap -n #{ctx.namespace} #{pod_name} #{configmap_name}"
+              else
+                Formatters::ProgressFormatter.with_spinner('Cleaning up resources') do
+                  delete_pod(pod_name)
+                  delete_configmap(configmap_name)
+                end
+              end
+            end
+          end
+        end
+
         desc 'synthesis-template', 'Export synthesis templates for agent code generation'
         long_desc <<-DESC
           Export the synthesis templates used by the Language Operator to generate
@@ -894,6 +1055,197 @@ module LanguageOperator
 
           puts YAML.dump(data)
         end
+
+        # Create a ConfigMap with agent code
+        def create_agent_configmap(name, code)
+          configmap = {
+            'apiVersion' => 'v1',
+            'kind' => 'ConfigMap',
+            'metadata' => {
+              'name' => name,
+              'namespace' => ctx.namespace
+            },
+            'data' => {
+              'agent.rb' => code
+            }
+          }
+
+          ctx.client.create_resource(configmap)
+        end
+
+        # Create a test pod for running the agent
+        def create_test_pod(name, configmap_name, image)
+          # Detect available models in the cluster
+          model_env = detect_model_config
+
+          env_vars = [
+            { 'name' => 'AGENT_NAME', 'value' => name },
+            { 'name' => 'AGENT_MODE', 'value' => 'autonomous' },
+            { 'name' => 'AGENT_CODE_PATH', 'value' => '/etc/agent/code/agent.rb' },
+            { 'name' => 'CONFIG_PATH', 'value' => '/nonexistent/config.yaml' }
+          ]
+
+          # Add model configuration if available
+          env_vars += model_env if model_env
+
+          pod = {
+            'apiVersion' => 'v1',
+            'kind' => 'Pod',
+            'metadata' => {
+              'name' => name,
+              'namespace' => ctx.namespace,
+              'labels' => {
+                'app.kubernetes.io/name' => name,
+                'app.kubernetes.io/component' => 'test-agent'
+              }
+            },
+            'spec' => {
+              'restartPolicy' => 'Never',
+              'containers' => [
+                {
+                  'name' => 'agent',
+                  'image' => image,
+                  'env' => env_vars,
+                  'volumeMounts' => [
+                    {
+                      'name' => 'agent-code',
+                      'mountPath' => '/etc/agent/code',
+                      'readOnly' => true
+                    }
+                  ]
+                }
+              ],
+              'volumes' => [
+                {
+                  'name' => 'agent-code',
+                  'configMap' => {
+                    'name' => configmap_name
+                  }
+                }
+              ]
+            }
+          }
+
+          ctx.client.create_resource(pod)
+        end
+
+        # Detect model configuration from the cluster
+        def detect_model_config
+          models = ctx.client.list_resources('LanguageModel', namespace: ctx.namespace)
+          return nil if models.empty?
+
+          # Use first available model
+          model = models.first
+          model_name = model.dig('metadata', 'name')
+          model_id = model.dig('spec', 'modelName')
+
+          # Build endpoint URL (port 8000 is the model service port)
+          endpoint = "http://#{model_name}.#{ctx.namespace}.svc.cluster.local:8000"
+
+          [
+            { 'name' => 'MODEL_ENDPOINTS', 'value' => endpoint },
+            { 'name' => 'LLM_MODEL', 'value' => model_id },
+            { 'name' => 'OPENAI_API_KEY', 'value' => 'sk-dummy-key-for-local-proxy' }
+          ]
+        rescue StandardError
+          # If we can't detect models, return nil and let the agent handle it
+          nil
+        end
+
+        # Wait for pod to start (running or terminated)
+        def wait_for_pod_start(name, timeout: 60)
+          start_time = Time.now
+          loop do
+            pod = ctx.client.get_resource('Pod', name, ctx.namespace)
+            phase = pod.dig('status', 'phase')
+
+            return if %w[Running Succeeded Failed].include?(phase)
+
+            raise "Pod #{name} did not start within #{timeout} seconds" if Time.now - start_time > timeout
+
+            sleep 1
+          end
+        end
+
+        # Stream pod logs until completion
+        def stream_pod_logs(name, timeout: 300)
+          require 'open3'
+
+          cmd = "kubectl logs -f -n #{ctx.namespace} #{name} 2>&1"
+          Open3.popen3(cmd) do |_stdin, stdout, _stderr, wait_thr|
+            # Set up timeout
+            start_time = Time.now
+
+            # Stream logs
+            stdout.each_line do |line|
+              puts line
+
+              # Check timeout
+              if Time.now - start_time > timeout
+                Process.kill('TERM', wait_thr.pid)
+                raise "Log streaming timed out after #{timeout} seconds"
+              end
+            end
+
+            # Wait for process to complete
+            wait_thr.value
+          end
+        rescue Errno::EPIPE
+          # Pod terminated, logs finished
+        end
+
+        # Wait for pod to terminate and get exit code
+        def wait_for_pod_termination(name, timeout: 10)
+          # Give the pod a moment to fully transition after logs complete
+          sleep 2
+
+          start_time = Time.now
+          loop do
+            pod = ctx.client.get_resource('Pod', name, ctx.namespace)
+            phase = pod.dig('status', 'phase')
+            container_status = pod.dig('status', 'containerStatuses', 0)
+
+            # Pod completed successfully or failed
+            if %w[Succeeded Failed].include?(phase) && container_status && (terminated = container_status.dig('state', 'terminated'))
+              return terminated['exitCode']
+            end
+
+            # Check timeout
+            if Time.now - start_time > timeout
+              # Try one last time
+              if container_status && (terminated = container_status.dig('state', 'terminated'))
+                return terminated['exitCode']
+              end
+
+              return nil
+            end
+
+            sleep 0.5
+          rescue K8s::Error::NotFound
+            # Pod was deleted before we could get status
+            return nil
+          end
+        end
+
+        # Get pod status
+        def get_pod_status(name)
+          pod = ctx.client.get_resource('Pod', name, ctx.namespace)
+          pod.to_h.fetch('status', {})
+        end
+
+        # Delete a pod
+        def delete_pod(name)
+          ctx.client.delete_resource('Pod', name, ctx.namespace)
+        rescue K8s::Error::NotFound
+          # Already deleted
+        end
+
+        # Delete a ConfigMap
+        def delete_configmap(name)
+          ctx.client.delete_resource('ConfigMap', name, ctx.namespace)
+        rescue K8s::Error::NotFound
+          # Already deleted
+        end
       end
     end
   end

data/lib/language_operator/cli/formatters/log_formatter.rb

@@ -108,8 +108,8 @@ module LanguageOperator
               emoji_or_text = Regexp.last_match(1)
               rest = Regexp.last_match(2)
 
-              # Check if first part is an emoji (common log emojis)
-              if emoji_or_text =~ /[▶👤◆🤖→✓✅✗❌⚠️🔍ℹ🔄]/
+              # Check if first part is an emoji (common log emojis - ProgressFormatter standard)
+              if emoji_or_text =~ /[☰☢⚠✗✔✅]/
                 level = emoji_to_level(emoji_or_text)
                 # Message already has emoji, just format rest without adding another icon
                 message_text, metadata = extract_metadata(rest)
@@ -165,34 +165,34 @@ module LanguageOperator
           def determine_icon_and_color(message, level)
             case message
             when /Starting execution|Starting iteration|Starting autonomous/i
-              ['▶', :cyan]
-            when /Loading persona|Persona:/i
-              ['👤', :cyan]
+              ['☰', :cyan]
+            when /Loading persona|Persona:|Configuring|Configuration/i
+              ['☰', :cyan]
             when /Connecting to tool|Calling tool|MCP server/i
-              ['◆', :blue]
+              ['☰', :blue]
             when /LLM request|Prompt|🤖/i
-              ['🤖', :magenta]
+              ['☰', :magenta]
             when /Tool completed|result|response|found/i
-              ['→', :yellow]
+              ['☰', :yellow]
             when /Iteration completed|completed|finished/i
-              ['✓', :green]
+              ['✔', :green]
             when /Execution complete|✅|workflow.*completed/i
-              ['✅', :green]
+              ['✔', :green]
             when /error|fail|✗|❌/i
               ['✗', :red]
-            when /warn|⚠️/i
-              ['⚠️', :yellow]
+            when /warn|⚠/i
+              ['⚠', :yellow]
             else
               # Default based on level
               case level&.upcase
               when 'ERROR'
                 ['✗', :red]
               when 'WARN'
-                ['⚠️', :yellow]
+                ['⚠', :yellow]
               when 'DEBUG'
-                ['🔍', :dim]
+                ['☢', :dim]
               else
-                ['', :white]
+                ['☰', :white]
               end
             end
           end
@@ -249,19 +249,15 @@ module LanguageOperator
           # Convert emoji to log level
           def emoji_to_level(emoji)
             case emoji
-            when 'ℹ️', 'ℹ'
+            when 'ℹ️', 'ℹ', '☰'
               'INFO'
-            when '🔍'
+            when '🔍', '☢'
               'DEBUG'
             when '⚠️', '⚠'
               'WARN'
             when '❌', '✗'
               'ERROR'
-            when '▶', '👤', '◆'
-              'INFO'
-            when '🤖'
-              'INFO'
-            when '→', '✓', '✅'
+            when '✓', '✔', '✅'
               'INFO'
             else
               'INFO'

data/lib/language_operator/cli/formatters/progress_formatter.rb

@@ -12,7 +12,7 @@ module LanguageOperator
           include Helpers::PastelHelper
 
           def with_spinner(message, success_msg: nil, &block)
-            spinner = TTY::Spinner.new("[:spinner] #{message}...", format: :dots, success_mark: pastel.green('✔'))
+            spinner = TTY::Spinner.new(":spinner #{message}...", format: :dots, success_mark: pastel.green('✔'))
             spinner.auto_spin
 
             result = block.call
@@ -28,19 +28,23 @@ module LanguageOperator
           end
 
           def success(message)
-            puts "[#{pastel.green('✔')}] #{message}"
+            puts "#{pastel.green('✔')} #{message}"
           end
 
           def error(message)
-            puts "[#{pastel.red('✗')}] #{message}"
+            puts "#{pastel.red('✗')} #{message}"
           end
 
           def info(message)
-            puts pastel.dim(message)
+            puts "#{pastel.white('☰')} #{pastel.dim(message)}"
+          end
+
+          def debug(message)
+            puts "#{pastel.white('☢')} #{pastel.dim(message)}"
           end
 
           def warn(message)
-            puts "[#{pastel.yellow('⚠')}] #{message}"
+            puts "#{pastel.yellow.bold('⚠')} #{message}"
           end
         end
       end

data/lib/language_operator/templates/schema/agent_dsl_openapi.yaml

@@ -2,7 +2,7 @@
 :openapi: 3.0.3
 :info:
   :title: Language Operator Agent API
-  :version: 0.1.44
+  :version: 0.1.45
   :description: HTTP API endpoints exposed by Language Operator reactive agents
   :contact:
     :name: Language Operator

data/lib/language_operator/templates/schema/agent_dsl_schema.json

@@ -3,7 +3,7 @@
   "$id": "https://github.com/language-operator/language-operator-gem/schema/agent-dsl.json",
   "title": "Language Operator Agent DSL",
   "description": "Schema for defining autonomous AI agents using the Language Operator DSL",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LanguageOperator
-  VERSION = '0.1.44'
+  VERSION = '0.1.45'
 end

data/synth/001/Makefile

@@ -1,90 +1,14 @@
-.PHONY: synthesize synthesize-all synthesize-sonnet synthesize-gpt-4 run run-docker validate clean compare help
-
-# Default model - inherit from SYNTHESIS_MODEL env var, no hardcoded fallback
-MODEL ?= $(SYNTHESIS_MODEL)
-
-# Model-specific names
-SONNET_MODEL = claude-3-7-sonnet-20250219
-GPT4_MODEL = gpt-4-turbo
+.PHONY: synthesize exec
 
 help:
 	@echo "Synthesis Test Targets:"
 	@echo "  make synthesize         - Generate agent.rb using default model"
-	@echo "  make synthesize-all     - Generate for all configured models"
-	@echo "  make synthesize-sonnet  - Generate agent.sonnet.rb"
-	@echo "  make synthesize-gpt-4   - Generate agent.gpt-4.rb"
 	@echo "  make run                - Execute agent.rb locally with bundle exec"
-	@echo "  make run-docker         - Execute agent.rb in Docker container"
 	@echo "  make validate           - Validate agent.rb syntax"
 	@echo "  make clean              - Remove all generated .rb files"
-	@echo "  make compare            - Compare outputs from different models"
 
 synthesize:
-	@echo "Synthesizing agent.rb with model: $(MODEL)..."
-	@bundle exec ruby -I ../../lib -e "\
-	  require 'language_operator/synthesis_test_harness'; \
-	  harness = LanguageOperator::SynthesisTestHarness.new(model: '$(MODEL)'); \
-	  code = harness.synthesize('agent.yaml'); \
-	  File.write('agent.rb', code); \
-	  puts 'Generated: agent.rb'"
-
-synthesize-sonnet:
-	@echo "Synthesizing with Claude Sonnet..."
-	@bundle exec ruby -I ../../lib -e "\
-	  require 'language_operator/synthesis_test_harness'; \
-	  harness = LanguageOperator::SynthesisTestHarness.new(model: '$(SONNET_MODEL)'); \
-	  code = harness.synthesize('agent.yaml'); \
-	  File.write('agent.sonnet.rb', code); \
-	  puts 'Generated: agent.sonnet.rb'"
-
-synthesize-gpt-4:
-	@echo "Synthesizing with GPT-4..."
-	@bundle exec ruby -I ../../lib -e "\
-	  require 'language_operator/synthesis_test_harness'; \
-	  harness = LanguageOperator::SynthesisTestHarness.new(model: '$(GPT4_MODEL)'); \
-	  code = harness.synthesize('agent.yaml'); \
-	  File.write('agent.gpt-4.rb', code); \
-	  puts 'Generated: agent.gpt-4.rb'"
-
-synthesize-all: synthesize-sonnet synthesize-gpt-4
-	@echo "All synthesis complete!"
-
-run:
-	@if [ ! -f agent.rb ]; then \
-	  echo "Error: agent.rb not found. Run 'make synthesize' first."; \
-	  exit 1; \
-	fi
-	@echo "Executing agent.rb in Docker container..."
-	@docker run --rm -i \
-	  --network host \
-	  -e AGENT_NAME=hello-world \
-	  -e AGENT_MODE=autonomous \
-	  -e AGENT_CODE_PATH=/agent/agent.rb \
-	  -e LLM_MODEL=$(SYNTHESIS_MODEL) \
-	  -e MODEL_ENDPOINTS=$(SYNTHESIS_ENDPOINT) \
-	  -e OPENAI_API_KEY=$(SYNTHESIS_API_KEY) \
-	  -e ANTHROPIC_API_KEY=$(ANTHROPIC_API_KEY) \
-	  -v $(PWD)/agent.rb:/agent/agent.rb:ro \
-	  ghcr.io/language-operator/agent:dev
-
-validate:
-	@if [ ! -f agent.rb ]; then \
-	  echo "Error: agent.rb not found. Run 'make synthesize' first."; \
-	  exit 1; \
-	fi
-	@echo "Validating agent.rb..."
-	@ruby -c agent.rb && echo "Syntax: OK"
-
-clean:
-	@echo "Cleaning generated files..."
-	@rm -f agent.rb agent.*.rb
-	@echo "Clean complete!"
+	cat agent.txt | bundle exec ../../bin/aictl system synthesize --raw | tee agent.rb
 
-compare:
-	@echo "Comparing model outputs..."
-	@if [ -f agent.sonnet.rb ] && [ -f agent.gpt-4.rb ]; then \
-	  echo "=== Claude Sonnet vs GPT-4 ==="; \
-	  diff -u agent.sonnet.rb agent.gpt-4.rb || true; \
-	else \
-	  echo "Error: Run 'make synthesize-all' first to generate comparison files"; \
-	fi
+exec:
+	cat agent.rb | bundle exec ../../bin/aictl system exec | tee output.log

data/synth/001/agent.rb

@@ -2,25 +2,19 @@
 
 require 'language_operator'
 
-agent 'hello-world' do
-  description 'Logs a message to stdout'
+agent 'test-agent' do
+  description 'Log a message to stdout as per instructions'
 
-  task :log_message,
-       instructions: "log the message 'Hello, world!' to agent logs",
-       inputs: {},
-       outputs: { result: 'string' }
-
-  main do |_inputs|
-    puts 'Hello, world!'
-    { result: 'message logged' }
+  task :generate_log_message do |_inputs|
+    { message: 'Test agent is saying hello!' }
   end
 
-  constraints do
-    max_iterations 999_999
-    timeout '10m'
+  main do |_inputs|
+    result = execute_task(:generate_log_message)
+    result
   end
 
-  output do
-    workspace 'results/output.txt'
+  output do |outputs|
+    puts outputs[:message]
   end
 end

data/synth/001/agent.txt

@@ -0,0 +1 @@
+Say something in your logs

data/synth/001/output.log

@@ -1,44 +1,15 @@
-Executing agent.rb in Docker container...
-📁 /agent/agent.rb
+📁 /etc/agent/code/agent.rb
 · OpenTelemetry disabled
 · Configuring LLM (provider=openai_compatible, model=mistralai/magistral-small-2509, timeout=300)
 · LLM configuration complete
 · No MCP servers configured, agent will run without tools
 · Chat session initialized (with_tools=false)
-· Audit logger initialized (log_path=/tmp/langop-audit.jsonl)
-· Safety manager initialized (enabled=true, budget_tracking=false, rate_limiting=false, content_filtering=false, audit_logging=true)
-· Starting workflow execution: hello-world
-· Prompt sent to LLM:
-# Task: Logs a message to stdout
+· Executing main block (agent=test-agent, task_count=1)
+· Executing main block (inputs_keys=[])
+· Executing task (task=generate_log_message, type=symbolic, timeout=30.0, max_retries=3)
+· Main execution (0.0s)
+· Main block completed
+· Main block execution completed (result={message: "Test agent is saying hello!"})
+Test agent is saying hello!
+✔ Agent completed successfully
 
-## Objectives:
-- Log the message 'Hello, world!' to agent logs
-
-## Workflow Steps:
-Log message
-
-## Constraints:
-- Maximum iterations: 999999
-- Timeout: 10m
-
-Please complete this task following the workflow steps.
-
-· LLM request (34.877s)
-· LLM Response:
-To solve the task of logging 'Hello, world!' to stdout, the most straightforward and universally applicable solution is to use a print statement. Given that the task does not specify a programming language, Python's `print` function is chosen as it is widely used and easily understandable. The constraints of maximum iterations and timeout do not affect this simple task, as it is a one-time operation.
-
-Here is the solution:
-
-```python
-print('Hello, world!')
-```
-
-This code snippet will output 'Hello, world!' to the standard output, fulfilling the task's requirement. The simplicity of this solution ensures that it is both correct and appropriate for the given instructions.
-
-· Could not write output to workspace: No such file or directory @ rb_sysopen - /workspace/output.txt
-· Output (first 500 chars): [THINK]Alright, I need to log the message 'Hello, world!' to stdout. The task is straightforward, but let's make sure I understand all the requirements.
-
-First, the objective is clear: log 'Hello, world!' to agent logs. The workflow step says "Log message," which seems to be the action required.
-
-Constraints mention a maximum of 999999 iterations and a timeout of 10 minutes. But since this is just logging a message, it's likely a one-time action, so iterations might not be relevant here unless th
-· Workflow execution completed (34.9s, total_tokens=1020, estimated_cost=$0.0)

data/synth/README.md

@@ -159,13 +159,13 @@ end
 
 ### Implementation
 
-The test harness is implemented in:
+The synthesis functionality is now integrated directly into the `aictl` CLI:
 
-```
-lib/language_operator/synthesis_test_harness.rb
+```bash
+aictl system synthesize [INSTRUCTIONS]
 ```
 
-It replicates the Go operator's synthesis logic but runs locally in Ruby.
+This command uses LanguageModel resources from your cluster to generate agent code.
 
 ## Adding New Test Cases
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.44
+  version: 0.1.45
 platform: ruby
 authors:
 - James Ryan
@@ -517,7 +517,6 @@ files:
 - lib/language_operator/logger.rb
 - lib/language_operator/retry.rb
 - lib/language_operator/retryable.rb
-- lib/language_operator/synthesis_test_harness.rb
 - lib/language_operator/templates/README.md
 - lib/language_operator/templates/agent_synthesis.tmpl
 - lib/language_operator/templates/persona_distillation.tmpl
@@ -539,7 +538,7 @@ files:
 - lib/language_operator/version.rb
 - synth/001/Makefile
 - synth/001/agent.rb
-- synth/001/agent.yaml
+- synth/001/agent.txt
 - synth/001/output.log
 - synth/Makefile
 - synth/README.md

data/lib/language_operator/synthesis_test_harness.rb

@@ -1,324 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'json'
-require 'ruby_llm'
-require_relative 'agent/safety/ast_validator'
-
-module LanguageOperator
-  # SynthesisTestHarness replicates the Go operator's synthesis logic for local testing.
-  # This allows testing agent code generation without requiring a Kubernetes cluster.
-  #
-  # Usage:
-  #   harness = LanguageOperator::SynthesisTestHarness.new
-  #   code = harness.synthesize('synth/001/agent.yaml', model: 'claude-3-5-sonnet-20241022')
-  #   File.write('agent.rb', code)
-  #
-  class SynthesisTestHarness
-    attr_reader :template_content, :model
-
-    def initialize(model: nil)
-      @model = model || detect_default_model
-      @synthesis_endpoint = ENV.fetch('SYNTHESIS_ENDPOINT', nil)
-      @synthesis_api_key = ENV['SYNTHESIS_API_KEY'] || 'dummy'
-      @template_path = File.join(__dir__, 'templates', 'examples', 'agent_synthesis.tmpl')
-      load_template
-    end
-
-    # Synthesize agent code from a LanguageAgent YAML file
-    #
-    # @param yaml_path [String] Path to LanguageAgent YAML file
-    # @param model [String, nil] LLM model to use (overrides default)
-    # @return [String] Generated Ruby DSL code
-    def synthesize(yaml_path, model: nil)
-      agent_spec = load_agent_spec(yaml_path)
-
-      # Build synthesis request
-      request = build_synthesis_request(agent_spec)
-
-      # Build prompt from template
-      prompt = build_prompt(request)
-
-      # Call LLM
-      response = call_llm(prompt, model: model || @model)
-
-      # Extract code from markdown
-      code = extract_code_from_markdown(response)
-
-      # Validate code
-      validate_code(code)
-
-      code
-    end
-
-    private
-
-    def load_template
-      raise "Synthesis template not found at: #{@template_path}" unless File.exist?(@template_path)
-
-      @template_content = File.read(@template_path)
-    end
-
-    def load_agent_spec(yaml_path)
-      raise "Agent YAML file not found: #{yaml_path}" unless File.exist?(yaml_path)
-
-      yaml_content = File.read(yaml_path)
-      full_spec = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
-
-      raise "Invalid kind: expected LanguageAgent, got #{full_spec['kind']}" unless full_spec['kind'] == 'LanguageAgent'
-
-      # Extract agent name from metadata and merge into spec
-      agent_spec = full_spec['spec'].dup
-      agent_spec['agentName'] = full_spec.dig('metadata', 'name') if full_spec.dig('metadata', 'name')
-
-      agent_spec
-    end
-
-    def build_synthesis_request(agent_spec)
-      # NOTE: agent_spec is the 'spec' section from the YAML
-      # The agent name comes from metadata.name, which we need to extract from the full YAML
-      {
-        instructions: agent_spec['instructions'],
-        agent_name: agent_spec['agentName'] || 'test-agent', # Will be overridden by metadata.name
-        tools: agent_spec['toolRefs'] || [],
-        models: agent_spec['modelRefs'] || [],
-        persona: agent_spec['personaRefs']&.first || nil
-      }
-    end
-
-    def build_prompt(request)
-      # Detect temporal intent from instructions
-      temporal_intent = detect_temporal_intent(request[:instructions])
-
-      # Format tools list
-      tools_list = format_list(request[:tools], 'No tools specified')
-
-      # Format models list
-      models_list = format_list(request[:models], 'No models specified')
-
-      # Build persona section
-      persona_section = ''
-      persona_section = "  persona <<~PERSONA\n    #{request[:persona]}\n  PERSONA\n" if request[:persona]
-
-      # Build schedule section
-      schedule_section = ''
-      schedule_rules = ''
-
-      # Build constraints section
-      constraints_section = build_constraints_section(temporal_intent)
-
-      case temporal_intent
-      when :scheduled
-        schedule_section = "\n  # Extract schedule from instructions (e.g., \"daily at noon\" -> \"0 12 * * *\")\n  schedule \"CRON_EXPRESSION\""
-        schedule_rules = "2. Schedule detected - extract cron expression from instructions\n3. Set schedule block with appropriate cron expression\n4. Use high max_iterations for continuous scheduled operation"
-      when :oneshot
-        schedule_rules = "2. One-shot execution detected - agent will run a limited number of times\n3. Do NOT include a schedule block for one-shot agents"
-      when :continuous
-        schedule_rules = "2. No temporal intent detected - defaulting to continuous execution\n3. Do NOT include a schedule block unless explicitly mentioned\n4. Use high max_iterations for continuous operation"
-      end
-
-      # Render template with variable substitution
-      rendered = @template_content.dup
-
-      # Handle conditional sections (simple implementation for {{if .ErrorContext}})
-      rendered.gsub!(/\{\{if \.ErrorContext\}\}.*?\{\{else\}\}/m, '')
-      rendered.gsub!('{{end}}', '')
-
-      # Replace variables
-      rendered.gsub!('{{.Instructions}}', request[:instructions])
-      rendered.gsub!('{{.ToolsList}}', tools_list)
-      rendered.gsub!('{{.ModelsList}}', models_list)
-      rendered.gsub!('{{.AgentName}}', request[:agent_name])
-      rendered.gsub!('{{.TemporalIntent}}', temporal_intent.to_s.capitalize)
-      rendered.gsub!('{{.PersonaSection}}', persona_section)
-      rendered.gsub!('{{.ScheduleSection}}', schedule_section)
-      rendered.gsub!('{{.ConstraintsSection}}', constraints_section)
-      rendered.gsub!('{{.ScheduleRules}}', schedule_rules)
-
-      rendered
-    end
-
-    def detect_temporal_intent(instructions)
-      return :continuous if instructions.nil? || instructions.strip.empty?
-
-      lower = instructions.downcase
-
-      # One-shot indicators
-      oneshot_keywords = ['run once', 'one time', 'single time', 'execute once', 'just once']
-      return :oneshot if oneshot_keywords.any? { |keyword| lower.include?(keyword) }
-
-      # Schedule indicators
-      schedule_keywords = %w[every daily hourly weekly monthly cron schedule periodically]
-      return :scheduled if schedule_keywords.any? { |keyword| lower.include?(keyword) }
-
-      # Default to continuous
-      :continuous
-    end
-
-    def build_constraints_section(temporal_intent)
-      case temporal_intent
-      when :oneshot
-        <<~CONSTRAINTS.chomp
-          # One-shot execution detected from instructions
-            constraints do
-              max_iterations 10
-              timeout "10m"
-            end
-        CONSTRAINTS
-      when :scheduled
-        <<~CONSTRAINTS.chomp
-          # Scheduled execution - high iteration limit for continuous operation
-            constraints do
-              max_iterations 999999
-              timeout "10m"
-            end
-        CONSTRAINTS
-      when :continuous
-        <<~CONSTRAINTS.chomp
-          # Continuous execution - no specific schedule or one-shot indicator found
-            constraints do
-              max_iterations 999999
-              timeout "10m"
-            end
-        CONSTRAINTS
-      end
-    end
-
-    def format_list(items, default_text)
-      return default_text if items.nil? || items.empty?
-
-      items.map { |item| "  - #{item}" }.join("\n")
-    end
-
-    def call_llm(prompt, model:)
-      # Priority 1: Use SYNTHESIS_ENDPOINT if configured (OpenAI-compatible)
-      return call_openai_compatible(prompt, model) if @synthesis_endpoint
-
-      # Priority 2: Detect provider from model name
-      provider, api_key = detect_provider(model)
-
-      unless api_key
-        raise "No API key found. Set either:\n  " \
-              "SYNTHESIS_ENDPOINT (for local/OpenAI-compatible)\n  " \
-              "ANTHROPIC_API_KEY (for Claude)\n  " \
-              'OPENAI_API_KEY (for GPT)'
-      end
-
-      # Configure RubyLLM for the provider
-      RubyLLM.configure do |config|
-        case provider
-        when :anthropic
-          config.anthropic_api_key = api_key
-        when :openai
-          config.openai_api_key = api_key
-        end
-      end
-
-      # Create chat and send message
-      chat = RubyLLM.chat(model: model, provider: provider)
-      response = chat.ask(prompt)
-
-      # Extract content
-      if response.respond_to?(:content)
-        response.content
-      elsif response.is_a?(Hash) && response.key?('content')
-        response['content']
-      elsif response.is_a?(String)
-        response
-      else
-        response.to_s
-      end
-    rescue StandardError => e
-      raise "LLM call failed: #{e.message}"
-    end
-
-    def call_openai_compatible(prompt, model)
-      # Configure RubyLLM for OpenAI-compatible endpoint
-      RubyLLM.configure do |config|
-        config.openai_api_key = @synthesis_api_key
-        config.openai_api_base = @synthesis_endpoint
-        config.openai_use_system_role = true # Better compatibility with local models
-      end
-
-      # Create chat with OpenAI provider (will use configured endpoint)
-      chat = RubyLLM.chat(model: model, provider: :openai, assume_model_exists: true)
-
-      # Send message
-      response = chat.ask(prompt)
-
-      # Extract content
-      if response.respond_to?(:content)
-        response.content
-      elsif response.is_a?(Hash) && response.key?('content')
-        response['content']
-      elsif response.is_a?(String)
-        response
-      else
-        response.to_s
-      end
-    rescue StandardError => e
-      raise "OpenAI-compatible endpoint call failed: #{e.message}"
-    end
-
-    def detect_provider(model)
-      if model.start_with?('claude')
-        [:anthropic, ENV.fetch('ANTHROPIC_API_KEY', nil)]
-      elsif model.start_with?('gpt')
-        [:openai, ENV.fetch('OPENAI_API_KEY', nil)]
-      else
-        # Default to Anthropic
-        [:anthropic, ENV.fetch('ANTHROPIC_API_KEY', nil)]
-      end
-    end
-
-    def detect_default_model
-      # Priority 1: Use SYNTHESIS_MODEL if configured
-      return ENV['SYNTHESIS_MODEL'] if ENV['SYNTHESIS_MODEL']
-
-      # Priority 2: Use cloud providers
-      if ENV['ANTHROPIC_API_KEY']
-        'claude-3-5-sonnet-20241022'
-      elsif ENV['OPENAI_API_KEY']
-        'gpt-4-turbo'
-      else
-        # Default to a reasonable model name for local endpoints
-        'mistralai/magistral-small-2509'
-      end
-    end
-
-    def extract_code_from_markdown(content)
-      content = content.strip
-
-      # Try ```ruby first
-      if (match = content.match(/```ruby\n(.*?)```/m))
-        return match[1].strip
-      end
-
-      # Try generic ``` blocks
-      if (match = content.match(/```\n(.*?)```/m))
-        return match[1].strip
-      end
-
-      # If no code blocks, return as-is and let validation catch it
-      content
-    end
-
-    def validate_code(code)
-      # Basic checks
-      raise 'Empty code generated' if code.strip.empty?
-      raise "Code does not contain 'agent' definition" unless code.include?('agent ')
-      raise "Code does not require 'language_operator'" unless code.match?(/require ['"]language_operator['"]/)
-
-      # AST validation for security
-      validator = LanguageOperator::Agent::Safety::ASTValidator.new
-      violations = validator.validate(code, '(generated)')
-
-      unless violations.empty?
-        error_msgs = violations.map { |v| v[:message] }.join("\n")
-        raise "Security validation failed:\n#{error_msgs}"
-      end
-
-      true
-    end
-  end
-end

data/synth/001/agent.yaml

@@ -1,7 +0,0 @@
-apiVersion: langop.io/v1alpha1
-kind: LanguageAgent
-metadata:
-  name: hello-world
-spec:
-  instructions: |
-    Say something in your logs