language-operator 0.1.61 → 0.1.62

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        # DSL schema export command
+        module Schema
+          def self.included(base)
+            base.class_eval do
+              desc 'schema', 'Export the DSL schema in various formats'
+              long_desc <<-DESC
+                Export the Language Operator Agent DSL schema in various formats.
+
+                The schema documents all available DSL methods, parameters, validation
+                patterns, and structure. Useful for template validation, documentation
+                generation, and IDE autocomplete.
+
+                Examples:
+                  # Export JSON schema (default)
+                  aictl system schema
+
+                  # Export as YAML
+                  aictl system schema --format yaml
+
+                  # Export OpenAPI 3.0 specification
+                  aictl system schema --format openapi
+
+                  # Show schema version only
+                  aictl system schema --version
+
+                  # Save to file
+                  aictl system schema > schema.json
+                  aictl system schema --format openapi > openapi.json
+              DESC
+              option :format, type: :string, default: 'json', desc: 'Output format (json, yaml, openapi)'
+              option :version, type: :boolean, default: false, desc: 'Show schema version only'
+              def schema
+                handle_command_error('generate schema') do
+                  # Handle version flag
+                  if options[:version]
+                    puts Dsl::Schema.version
+                    return
+                  end
+
+                  # Generate schema based on format
+                  format = options[:format].downcase
+                  case format
+                  when 'json'
+                    output_json_schema
+                  when 'yaml'
+                    output_yaml_schema
+                  when 'openapi'
+                    output_openapi_schema
+                  else
+                    Formatters::ProgressFormatter.error("Invalid format: #{format}")
+                    puts
+                    puts 'Supported formats: json, yaml, openapi'
+                    exit 1
+                  end
+                end
+              end
+
+              private
+
+              # Output JSON Schema v7
+              def output_json_schema
+                schema = Dsl::Schema.to_json_schema
+                puts JSON.pretty_generate(schema)
+              end
+
+              # Output YAML Schema
+              def output_yaml_schema
+                schema = Dsl::Schema.to_json_schema
+                puts YAML.dump(schema.transform_keys(&:to_s))
+              end
+
+              # Output OpenAPI 3.0 specification
+              def output_openapi_schema
+                spec = Dsl::Schema.to_openapi
+                puts JSON.pretty_generate(spec)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        # Synthesis template export command
+        module SynthesisTemplate
+          def self.included(base)
+            base.class_eval do
+              desc 'synthesis-template', 'Export synthesis templates for agent code generation'
+              long_desc <<-DESC
+                Export the synthesis templates used by the Language Operator to generate
+                agent code from natural language instructions.
+
+                These templates are used by the operator's synthesis engine to convert
+                user instructions into executable Ruby DSL code.
+
+                Examples:
+                  # Export agent synthesis template (default)
+                  aictl system synthesis-template
+
+                  # Export persona distillation template
+                  aictl system synthesis-template --type persona
+
+                  # Export as JSON with schema included
+                  aictl system synthesis-template --format json --with-schema
+
+                  # Export as YAML
+                  aictl system synthesis-template --format yaml
+
+                  # Validate template syntax
+                  aictl system synthesis-template --validate
+
+                  # Save to file
+                  aictl system synthesis-template > agent_synthesis.tmpl
+              DESC
+              option :format, type: :string, default: 'template', desc: 'Output format (template, json, yaml)'
+              option :type, type: :string, default: 'agent', desc: 'Template type (agent, persona)'
+              option :with_schema, type: :boolean, default: false, desc: 'Include DSL schema in output'
+              option :validate, type: :boolean, default: false, desc: 'Validate template syntax'
+              def synthesis_template
+                handle_command_error('load template') do
+                  # Validate type
+                  template_type = options[:type].downcase
+                  unless %w[agent persona].include?(template_type)
+                    Formatters::ProgressFormatter.error("Invalid template type: #{template_type}")
+                    puts
+                    puts 'Supported types: agent, persona'
+                    exit 1
+                  end
+
+                  # Load template
+                  template_content = load_template(template_type)
+
+                  # Validate if requested
+                  if options[:validate]
+                    validation_result = validate_template_content(template_content, template_type)
+
+                    # Display warnings if any
+                    unless validation_result[:warnings].empty?
+                      Formatters::ProgressFormatter.warn('Template validation warnings:')
+                      validation_result[:warnings].each do |warning|
+                        puts "  ⚠  #{warning}"
+                      end
+                      puts
+                    end
+
+                    # Display errors and exit if validation failed
+                    if validation_result[:valid]
+                      Formatters::ProgressFormatter.success('Template validation passed')
+                      return
+                    else
+                      Formatters::ProgressFormatter.error('Template validation failed:')
+                      validation_result[:errors].each do |error|
+                        puts "  ✗ #{error}"
+                      end
+                      exit 1
+                    end
+                  end
+
+                  # Generate output based on format
+                  format = options[:format].downcase
+                  case format
+                  when 'template'
+                    output_template_format(template_content)
+                  when 'json'
+                    output_json_format(template_content, template_type)
+                  when 'yaml'
+                    output_yaml_format(template_content, template_type)
+                  else
+                    Formatters::ProgressFormatter.error("Invalid format: #{format}")
+                    puts
+                    puts 'Supported formats: template, json, yaml'
+                    exit 1
+                  end
+                end
+              end
+
+              private
+
+              # Output raw template format
+              def output_template_format(content)
+                puts content
+              end
+
+              # Output JSON format with metadata
+              def output_json_format(content, type)
+                data = {
+                  version: Dsl::Schema.version,
+                  template_type: type,
+                  template: content
+                }
+
+                if options[:with_schema]
+                  data[:schema] = Dsl::Schema.to_json_schema
+                  data[:safe_agent_methods] = Dsl::Schema.safe_agent_methods
+                  data[:safe_tool_methods] = Dsl::Schema.safe_tool_methods
+                  data[:safe_helper_methods] = Dsl::Schema.safe_helper_methods
+                end
+
+                puts JSON.pretty_generate(data)
+              end
+
+              # Output YAML format with metadata
+              def output_yaml_format(content, type)
+                data = {
+                  'version' => Dsl::Schema.version,
+                  'template_type' => type,
+                  'template' => content
+                }
+
+                if options[:with_schema]
+                  data['schema'] = Dsl::Schema.to_json_schema.transform_keys(&:to_s)
+                  data['safe_agent_methods'] = Dsl::Schema.safe_agent_methods
+                  data['safe_tool_methods'] = Dsl::Schema.safe_tool_methods
+                  data['safe_helper_methods'] = Dsl::Schema.safe_helper_methods
+                end
+
+                puts YAML.dump(data)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        # Agent code synthesis command
+        module Synthesize
+          def self.included(base)
+            base.class_eval do
+              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.
+
+                This command uses a LanguageModel resource from your cluster to generate
+                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.
+
+                Examples:
+                  # Test with dry-run (show prompt only)
+                  aictl system synthesize "Monitor GitHub issues daily" --dry-run
+
+                  # Generate code from instructions (auto-selects first available model)
+                  aictl system synthesize "Send daily reports to Slack"
+
+                  # Use a specific cluster model
+                  aictl system synthesize "Process webhooks from GitHub" --model my-claude
+
+                  # 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 \\
+                    --tools github,slack \\
+                    --model my-gpt4
+              DESC
+              option :agent_name, type: :string, default: 'test-agent', desc: 'Name for the test agent'
+              option :tools, type: :string, desc: 'Comma-separated list of available tools'
+              option :models, type: :string, desc: 'Comma-separated list of available models (from cluster)'
+              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 = 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
+
+                  # Load synthesis template
+                  template_content = load_bundled_template('agent')
+
+                  # Detect temporal intent from instructions
+                  temporal_intent = detect_temporal_intent(instructions)
+
+                  # Prepare template data
+                  template_data = {
+                    'Instructions' => instructions,
+                    'AgentName' => options[:agent_name],
+                    'ToolsList' => format_tools_list(options[:tools]),
+                    'ModelsList' => format_models_list(options[:models]),
+                    'TemporalIntent' => temporal_intent,
+                    'PersonaSection' => '',
+                    'ScheduleSection' => temporal_intent == 'scheduled' ? '  schedule "0 */1 * * *"  # Example hourly schedule' : '',
+                    'ScheduleRules' => temporal_intent == 'scheduled' ? "\n2. Include schedule with cron expression\n3. Set mode to :scheduled\n4. " : "\n2. ",
+                    'ConstraintsSection' => '',
+                    'ErrorContext' => nil
+                  }
+
+                  # Render template (Go-style template syntax)
+                  rendered_prompt = render_go_template(template_content, template_data)
+
+                  if options[:dry_run]
+                    # Show the prompt that would be sent
+                    puts 'Synthesis Prompt Preview'
+                    puts '=' * 80
+                    puts
+                    puts rendered_prompt
+                    puts
+                    puts '=' * 80
+                    Formatters::ProgressFormatter.success('Dry-run complete - prompt displayed above')
+                    return
+                  end
+
+                  # Call LLM to generate code (no output - just do it)
+                  llm_response = call_llm_for_synthesis(rendered_prompt, selected_model)
+
+                  # Extract Ruby code from response
+                  generated_code = extract_ruby_code(llm_response)
+
+                  if generated_code.nil?
+                    Formatters::ProgressFormatter.error('Failed to extract Ruby code from LLM response')
+                    puts
+                    puts 'LLM Response:'
+                    puts llm_response
+                    exit 1
+                  end
+
+                  # Handle raw output
+                  if options[:raw]
+                    puts generated_code
+                    return
+                  end
+
+                  # Display formatted code
+                  highlighted_code = highlight_ruby_code(generated_code)
+
+                  puts highlighted_code
+                end
+              end
+
+              private
+
+              # Detect temporal intent from instructions (scheduled vs autonomous)
+              def detect_temporal_intent(instructions)
+                temporal_keywords = {
+                  scheduled: %w[daily weekly hourly monthly schedule cron every day week hour minute],
+                  autonomous: %w[monitor watch continuously constantly always loop]
+                }
+
+                instructions_lower = instructions.downcase
+
+                # Check for scheduled keywords
+                scheduled_matches = temporal_keywords[:scheduled].count { |keyword| instructions_lower.include?(keyword) }
+                autonomous_matches = temporal_keywords[:autonomous].count { |keyword| instructions_lower.include?(keyword) }
+
+                scheduled_matches > autonomous_matches ? 'scheduled' : 'autonomous'
+              end
+
+              # Format tools list for template
+              def format_tools_list(tools_str)
+                return 'No tools specified' if tools_str.nil? || tools_str.strip.empty?
+
+                tools = tools_str.split(',').map(&:strip)
+                tools.map { |tool| "- #{tool}" }.join("\n")
+              end
+
+              # Format models list for template
+              def format_models_list(models_str)
+                # If not specified, try to detect from cluster
+                if models_str.nil? || models_str.strip.empty?
+                  models = detect_available_models
+                  return models.map { |model| "- #{model}" }.join("\n") unless models.empty?
+
+                  return 'No models available (run: aictl model list)'
+                end
+
+                models = models_str.split(',').map(&:strip)
+                models.map { |model| "- #{model}" }.join("\n")
+              end
+
+              # Detect available models from cluster
+              def detect_available_models
+                models = ctx.client.list_resources('LanguageModel', namespace: ctx.namespace)
+                models.map { |m| m.dig('metadata', 'name') }
+              rescue StandardError => e
+                Formatters::ProgressFormatter.error("Failed to list models from cluster: #{e.message}")
+                []
+              end
+
+              # Select model to use for synthesis
+              def select_synthesis_model
+                # If --model option specified, use it
+                return options[:model] if options[:model]
+
+                # Otherwise, auto-select from available cluster models
+                available_models = detect_available_models
+
+                if available_models.empty?
+                  Formatters::ProgressFormatter.error('No models available in cluster')
+                  puts
+                  puts 'Please create a model first:'
+                  puts '  aictl model create'
+                  puts
+                  puts 'Or list existing models:'
+                  puts '  aictl model list'
+                  exit 1
+                end
+
+                # Auto-select first available model (silently)
+                available_models.first
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module System
+        # Template validation command
+        module ValidateTemplate
+          def self.included(base)
+            base.class_eval do
+              desc 'validate_template', 'Validate synthesis template against DSL schema'
+              long_desc <<-DESC
+                Validate a synthesis template file against the DSL schema.
+
+                Extracts Ruby code examples from the template and validates each example
+                against the Language Operator Agent DSL schema. Checks for dangerous
+                methods, syntax errors, and compliance with safe coding practices.
+
+                Examples:
+                  # Validate a custom template file
+                  aictl system validate_template --template /path/to/template.tmpl
+
+                  # Validate the bundled agent template (default)
+                  aictl system validate_template
+
+                  # Validate the bundled persona template
+                  aictl system validate_template --type persona
+
+                  # Verbose output with all violations
+                  aictl system validate_template --template mytemplate.tmpl --verbose
+              DESC
+              option :template, type: :string, desc: 'Path to template file (defaults to bundled template)'
+              option :type, type: :string, default: 'agent', desc: 'Template type if using bundled template (agent, persona)'
+              option :verbose, type: :boolean, default: false, desc: 'Show detailed violation information'
+              def validate_template
+                handle_command_error('validate template') do
+                  # Determine template source
+                  if options[:template]
+                    # Load custom template from file
+                    unless File.exist?(options[:template])
+                      Formatters::ProgressFormatter.error("Template file not found: #{options[:template]}")
+                      exit 1
+                    end
+                    template_content = File.read(options[:template])
+                    template_name = File.basename(options[:template])
+                  else
+                    # Load bundled template
+                    template_type = options[:type].downcase
+                    unless %w[agent persona].include?(template_type)
+                      Formatters::ProgressFormatter.error("Invalid template type: #{template_type}")
+                      puts
+                      puts 'Supported types: agent, persona'
+                      exit 1
+                    end
+                    template_content = load_bundled_template(template_type)
+                    template_name = "bundled #{template_type} template"
+                  end
+
+                  # Display header
+                  puts "Validating template: #{template_name}"
+                  puts '=' * 60
+                  puts
+
+                  # Extract code examples
+                  code_examples = extract_code_examples(template_content)
+
+                  if code_examples.empty?
+                    Formatters::ProgressFormatter.warn('No Ruby code examples found in template')
+                    puts
+                    puts 'Templates should contain Ruby code blocks like:'
+                    puts '```ruby'
+                    puts 'agent "my-agent" do'
+                    puts '  # ...'
+                    puts 'end'
+                    puts '```'
+                    exit 1
+                  end
+
+                  puts "Found #{code_examples.size} code example(s)"
+                  puts
+
+                  # Validate each example
+                  all_valid = true
+                  code_examples.each_with_index do |example, idx|
+                    puts "Example #{idx + 1} (starting at line #{example[:start_line]}):"
+                    puts '-' * 40
+
+                    result = validate_code_against_schema(example[:code])
+
+                    if result[:valid] && result[:warnings].empty?
+                      Formatters::ProgressFormatter.success('Valid - No issues found')
+                    elsif result[:valid]
+                      Formatters::ProgressFormatter.success('Valid - With warnings')
+                      result[:warnings].each do |warn|
+                        line = example[:start_line] + (warn[:location] || 0)
+                        puts "  ⚠  Line #{line}: #{warn[:message]}"
+                      end
+                    else
+                      Formatters::ProgressFormatter.error('Invalid - Violations detected')
+                      result[:errors].each do |err|
+                        line = example[:start_line] + (err[:location] || 0)
+                        puts "  ✗ Line #{line}: #{err[:message]}"
+                        puts "    Type: #{err[:type]}" if options[:verbose]
+                      end
+                      all_valid = false
+                    end
+
+                    puts
+                  end
+
+                  # Final summary
+                  puts '=' * 60
+                  if all_valid
+                    Formatters::ProgressFormatter.success('All examples are valid')
+                    exit 0
+                  else
+                    Formatters::ProgressFormatter.error('Validation failed')
+                    puts
+                    puts 'Fix the violations above and run validation again.'
+                    exit 1
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end