language-operator 0.1.46 → 0.1.47

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../helpers/pastel_helper'
+require_relative 'log_style'
 require 'json'
 require 'time'
 
@@ -108,12 +109,12 @@ module LanguageOperator
               emoji_or_text = Regexp.last_match(1)
               rest = Regexp.last_match(2)
 
-              # Check if first part is an emoji (common log emojis - ProgressFormatter standard)
+              # Check if first part is an emoji (common log emojis - LogStyle standard)
               if emoji_or_text =~ /[☰☢⚠✗✔✅]/
-                level = emoji_to_level(emoji_or_text)
+                level_sym = LogStyle.emoji_to_level(emoji_or_text)
                 # Message already has emoji, just format rest without adding another icon
                 message_text, metadata = extract_metadata(rest)
-                color = determine_color_from_level(level)
+                color = LogStyle.color(level_sym)
                 formatted = pastel.send(color, "#{emoji_or_text} #{message_text}")
                 formatted += " #{format_metadata(metadata)}" if metadata
                 formatted
@@ -163,38 +164,21 @@ module LanguageOperator
 
           # Determine icon and color based on message content
           def determine_icon_and_color(message, level)
-            case message
-            when /Starting execution|Starting iteration|Starting autonomous/i
-              ['☰', :cyan]
-            when /Loading persona|Persona:|Configuring|Configuration/i
-              ['☰', :cyan]
-            when /Connecting to tool|Calling tool|MCP server/i
-              ['☰', :blue]
-            when /LLM request|Prompt|🤖/i
-              ['☰', :magenta]
-            when /Tool completed|result|response|found/i
-              ['☰', :yellow]
-            when /Iteration completed|completed|finished/i
-              ['✔', :green]
-            when /Execution complete|✅|workflow.*completed/i
-              ['✔', :green]
-            when /error|fail|✗|❌/i
-              ['✗', :red]
-            when /warn|⚠/i
-              ['⚠', :yellow]
-            else
-              # Default based on level
-              case level&.upcase
-              when 'ERROR'
-                ['✗', :red]
-              when 'WARN'
-                ['⚠', :yellow]
-              when 'DEBUG'
-                ['☢', :dim]
-              else
-                ['☰', :white]
-              end
-            end
+            # Detect level from message content
+            detected_level = LogStyle.detect_level_from_message(message)
+
+            # Use detected level unless explicitly overridden
+            level_sym = if detected_level == :info
+                          level&.downcase&.to_sym || :info
+                        else
+                          detected_level
+                        end
+
+            # Get icon and color from LogStyle
+            icon = LogStyle.icon(level_sym)
+            color = LogStyle.color(level_sym)
+
+            [icon, color]
           end
 
           # Format metadata hash
@@ -245,38 +229,6 @@ module LanguageOperator
           def format_time(time)
             pastel.dim(time.strftime('%H:%M:%S'))
           end
-
-          # Convert emoji to log level
-          def emoji_to_level(emoji)
-            case emoji
-            when 'ℹ️', 'ℹ', '☰'
-              'INFO'
-            when '🔍', '☢'
-              'DEBUG'
-            when '⚠️', '⚠'
-              'WARN'
-            when '❌', '✗'
-              'ERROR'
-            when '✓', '✔', '✅'
-              'INFO'
-            else
-              'INFO'
-            end
-          end
-
-          # Determine color from log level
-          def determine_color_from_level(level)
-            case level&.upcase
-            when 'ERROR'
-              :red
-            when 'WARN'
-              :yellow
-            when 'DEBUG'
-              :dim
-            else
-              :white
-            end
-          end
         end
       end
     end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module CLI
+    module Formatters
+      # Centralized configuration for log level icons and colors
+      #
+      # Single source of truth for all logging/notification output across the codebase.
+      # This ensures consistent styling and makes it easy to customize icons and colors
+      # for all log levels in one place.
+      #
+      # @example Using LogStyle with Pastel
+      #   pastel = Pastel.new
+      #   puts LogStyle.format(:success, "Operation completed", pastel)
+      #   # => "\e[32m✔ Operation completed\e[0m"
+      #
+      # @example Getting icon and color separately
+      #   icon = LogStyle.icon(:error)    # => "✗"
+      #   color = LogStyle.color(:error)  # => :red
+      #
+      class LogStyle
+        # Style configuration for each log level
+        # @return [Hash] Mapping of log levels to icon and color
+        STYLES = {
+          debug: { icon: '☢', color: :dim },
+          info: { icon: '⚬', color: :cyan },
+          success: { icon: '✔', color: :green },
+          warn: { icon: '⚠', color: :yellow },
+          error: { icon: '✗', color: :red }
+        }.freeze
+
+        class << self
+          # Format a message with icon and color for the given log level
+          #
+          # @param level [Symbol] Log level (:debug, :info, :success, :warn, :error)
+          # @param message [String] Message to format
+          # @param pastel [Pastel] Pastel instance for applying colors
+          # @return [String] Formatted message with icon and color
+          def format(level, message, pastel)
+            style = STYLES[level] || STYLES[:info]
+            icon = style[:icon]
+            color = style[:color]
+
+            pastel.send(color, "#{icon} #{message}")
+          end
+
+          # Get the icon for a log level
+          #
+          # @param level [Symbol] Log level
+          # @return [String] Icon character
+          def icon(level)
+            STYLES.dig(level, :icon) || STYLES[:info][:icon]
+          end
+
+          # Get the color for a log level
+          #
+          # @param level [Symbol] Log level
+          # @return [Symbol] Color name (e.g., :red, :green)
+          def color(level)
+            STYLES.dig(level, :color) || STYLES[:info][:color]
+          end
+
+          # Get a styled icon with ANSI color codes embedded
+          #
+          # @param level [Symbol] Log level
+          # @param pastel [Pastel] Pastel instance for applying colors
+          # @return [String] Colored icon with ANSI escape codes
+          def styled_icon(level, pastel)
+            style = STYLES[level] || STYLES[:info]
+            pastel.send(style[:color], style[:icon])
+          end
+
+          # Detect log level from message content
+          #
+          # Useful for inferring log level from message text when not explicitly provided.
+          #
+          # @param message [String] Message text to analyze
+          # @return [Symbol] Detected log level
+          def detect_level_from_message(message)
+            case message
+            when /error|fail|✗|❌/i
+              :error
+            when /warn|⚠/i
+              :warn
+            when /completed|finished|success|✔|✅/i
+              :success
+            when /debug|☢/i
+              :debug
+            else
+              :info
+            end
+          end
+
+          # Convert emoji to log level symbol
+          #
+          # @param emoji [String] Emoji character
+          # @return [Symbol] Log level symbol
+          def emoji_to_level(emoji)
+            case emoji
+            when /[☰ℹ]/
+              :info
+            when /[☢🔍]/
+              :debug
+            when /⚠/
+              :warn
+            when /[✗❌]/
+              :error
+            when /[✔✅]/
+              :success
+            else
+              :info
+            end
+          end
+
+          # Get ANSI color code for a level (for Logger compatibility)
+          #
+          # @param level [Symbol, String] Log level
+          # @return [String] ANSI escape code with icon and color
+          def ansi_icon(level)
+            level_sym = level.to_s.downcase.to_sym
+            style = STYLES[level_sym] || STYLES[:info]
+            icon = style[:icon]
+            color_code = ansi_color_code(style[:color])
+
+            "#{color_code}#{icon}\e[0m"
+          end
+
+          private
+
+          # Get ANSI color code for a color name
+          def ansi_color_code(color)
+            case color
+            when :dim
+              "\e[1;90m"
+            when :cyan
+              "\e[1;36m"
+            when :green
+              "\e[1;32m"
+            when :yellow
+              "\e[1;33m"
+            when :red
+              "\e[1;31m"
+            else
+              "\e[0m"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require 'tty-spinner'
 require_relative '../helpers/pastel_helper'
+require_relative 'log_style'
 
 module LanguageOperator
   module CLI
@@ -12,7 +13,8 @@ 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('✔'))
+            success_icon = LogStyle.styled_icon(:success, pastel)
+            spinner = TTY::Spinner.new(":spinner #{message}...", format: :dots, success_mark: success_icon)
             spinner.auto_spin
 
             result = block.call
@@ -28,23 +30,25 @@ module LanguageOperator
           end
 
           def success(message)
-            puts "#{pastel.green('✔')} #{message}"
+            puts LogStyle.format(:success, message, pastel)
           end
 
           def error(message)
-            puts "#{pastel.red('✗')} #{message}"
+            puts LogStyle.format(:error, message, pastel)
           end
 
           def info(message)
-            puts "#{pastel.white('☰')} #{pastel.dim(message)}"
+            icon = LogStyle.styled_icon(:info, pastel)
+            puts "#{icon} #{pastel.dim(message)}"
           end
 
           def debug(message)
-            puts "#{pastel.white('☢')} #{pastel.dim(message)}"
+            icon = LogStyle.styled_icon(:debug, pastel)
+            puts "#{icon} #{pastel.dim(message)}"
           end
 
           def warn(message)
-            puts "#{pastel.yellow.bold('⚠')} #{message}"
+            puts "#{pastel.yellow.bold(LogStyle.icon(:warn))} #{message}"
           end
         end
       end

data/lib/language_operator/logger.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'logger'
+require_relative 'cli/formatters/log_style'
 
 module LanguageOperator
   # Structured logger with configurable output formats and levels
@@ -22,13 +23,6 @@ module LanguageOperator
       'ERROR' => ::Logger::ERROR
     }.freeze
 
-    LEVEL_EMOJI = {
-      'DEBUG' => "\e[1;90m☢\e[0m",   # Bold gray radioactive symbol
-      'INFO' => "\e[1;36m☰\e[0m",    # Bold cyan trigram
-      'WARN' => "\e[1;33m⚠\e[0m",    # Bold yellow warning
-      'ERROR' => "\e[1;31m✗\e[0m"    # Bold red cross
-    }.freeze
-
     attr_reader :logger, :format, :show_timing
 
     def initialize(component: 'Langop', format: nil, level: nil)
@@ -115,7 +109,8 @@ module LanguageOperator
     end
 
     def format_pretty(severity, message, **metadata)
-      emoji = LEVEL_EMOJI[severity.to_s.upcase] || '•'
+      level_sym = severity.to_s.downcase.to_sym
+      emoji = CLI::Formatters::LogStyle.ansi_icon(level_sym)
       parts = [emoji, message]
 
       metadata_str = format_metadata(**metadata)

data/lib/language_operator/templates/agent_synthesis.tmpl

@@ -177,44 +177,42 @@ end
 
 ## Your Task: Generate DSL v1 Agent
 
-Using the examples above as reference, generate Ruby DSL code in this format:
+Using the THREE CONCRETE EXAMPLES above (daily-report, code-reviewer, data-pipeline) as reference patterns, generate WORKING Ruby DSL code for the agent described in the user instructions.
 
-```ruby
+**CRITICAL REQUIREMENTS:**
+- DO NOT output placeholder text like "Brief description extracted from instructions" or "CRON_EXPRESSION"
+- DO NOT output generic names like `:task_name` or `param_name`
+- DO NOT copy the template structure below - USE THE WORKING EXAMPLES ABOVE
+- Generate ACTUAL, FUNCTIONAL code that implements the user's request
+- Use SPECIFIC task names, descriptions, and logic based on the user instructions
+
+The code structure should follow this pattern (with ACTUAL content, not placeholders):
+
+```
 require 'language_operator'
 
 agent "{{.AgentName}}" do
-  description "Brief description extracted from instructions"
+  description "<ACTUAL description based on user instructions>"
 {{.PersonaSection}}{{.ScheduleSection}}
-  # Break down instructions into tasks
-  # Each task needs:
-  # - instructions: what to do (for neural tasks)
-  # - inputs: hash with parameter types
-  # - outputs: hash with result types
-
-  task :task_name,
-    instructions: "clear description of what this task does",
-    inputs: { param_name: 'type' },
-    outputs: { result_name: 'type' }
-
-  # For symbolic tasks (when logic is simple/deterministic), use code blocks:
-  # task :task_name do |inputs|
-  #   { result: inputs[:param] * 2 }
-  # end
-
-  # REQUIRED: main block defines execution flow
+  # Define specific tasks needed for this agent
+  task :<ACTUAL_task_name>,
+    instructions: "<ACTUAL description of what this specific task does>",
+    inputs: { <actual_param>: '<actual_type>' },
+    outputs: { <actual_result>: '<actual_type>' }
+
+  # Add more tasks as needed based on user instructions
+
   main do |inputs|
-    result1 = execute_task(:task_name, inputs: { param_name: value })
-    # Chain tasks by passing outputs as inputs
-    result2 = execute_task(:another_task, inputs: result1)
-    result2  # Return final result
+    # ACTUAL execution flow implementing the user's request
+    result = execute_task(:<ACTUAL_task_name>, inputs: { <actual_param>: <actual_value> })
+    result
   end
 
 {{.ConstraintsSection}}
 
-  # Output handling
   output do |outputs|
-    # Save results, send notifications, etc.
-    puts "Agent completed: #{outputs.inspect}"
+    # ACTUAL output handling for this specific agent
+    puts outputs.inspect
   end
 end
 ```
@@ -231,7 +229,7 @@ end
 **Rules:**
 1. Generate ONLY the Ruby code within triple-backticks, no explanations before or after
 {{.ScheduleRules}}
-3. Break down instructions into clear tasks with type-safe contracts
+3. Break down the user's instructions into SPECIFIC tasks with type-safe contracts
 4. REQUIRED: Always include a `main` block that calls tasks via `execute_task()`
 5. For simple deterministic tasks, use symbolic code blocks (do |inputs| ... end)
 6. For complex/creative tasks, use neural tasks with instructions
@@ -240,4 +238,13 @@ end
 9. Type schemas are REQUIRED for all tasks (inputs/outputs hashes)
 10. Use the agent name: "{{.AgentName}}"
 
+**CRITICAL - VERIFY BEFORE OUTPUTTING:**
+- ✓ Did you read and understand the USER INSTRUCTIONS above?
+- ✓ Does your code IMPLEMENT those specific instructions?
+- ✓ Are all task names, descriptions, and logic SPECIFIC to the user's request?
+- ✓ Did you AVOID outputting placeholders like "task_name" or "CRON_EXPRESSION"?
+- ✓ Does the code actually DO what the user asked for?
+
+If you cannot answer YES to all of the above, re-read the user instructions and generate FUNCTIONAL code.
+
 Generate the code now:

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.46
+  :version: 0.1.47
   :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.46",
+  "version": "0.1.47",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/version.rb

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

data/synth/001/README.md

@@ -0,0 +1,72 @@
+# 001 - Minimal Viable Synthesis
+
+## Instructions
+
+"Say something in your logs"
+
+## Significance
+
+This is the **foundational validation** of the DSL v1 architecture. It proves that the entire synthesis pipeline works end-to-end with the simplest possible agent.
+
+Think of this as the "Hello World" of organic function synthesis - before we can validate learning, progressive synthesis, or neural task execution, we must first prove we can synthesize and execute *anything at all*.
+
+## What This Demonstrates
+
+### 1. Basic Synthesis Flow Works
+- **Natural language → Agent code generation** - The synthesis template can produce valid Ruby DSL
+- **Go operator synthesis** - The operator's synthesis controller generates executable code
+- **ConfigMap storage** - Synthesized code is stored and mounted correctly
+
+### 2. DSL v1 Core Primitives
+- **`task` definition** - Symbolic task with explicit implementation block
+- **`main` block** - Explicit entry point with imperative control flow
+- **`execute_task`** - Task invocation mechanism works
+- **`output` block** - Result handling and processing
+
+### 3. Ruby Runtime Execution
+- **DSL parsing** - Ruby gem can load and parse synthesized agents
+- **Task execution** - `TaskExecutor` can execute symbolic tasks
+- **Agent lifecycle** - Agent runs to completion successfully
+
+### 4. Symbolic Task Execution
+```ruby
+task :generate_log_message do |_inputs|
+  { message: 'Test agent is saying hello!' }
+end
+```
+
+This is a **symbolic organic function** - explicit code implementation with a stable contract:
+- **Contract**: `outputs: { message: 'string' }`
+- **Implementation**: Returns hard-coded message
+- **Caller**: `main` block calls via `execute_task(:generate_log_message)`
+
+## Why This Matters
+
+### Validates the Foundation
+Before building complex features (learning, neural execution, re-synthesis), we must prove the basic pipeline works:
+
+```
+User Instruction
+    ↓
+Synthesis (Go operator)
+    ↓
+ConfigMap (agent.rb)
+    ↓
+Ruby Runtime Execution
+    ↓
+Output
+```
+
+### Establishes DSL v1 Baseline
+This test uses the **new DSL v1 model** (task/main) rather than the old workflow/step model. It proves:
+- ✅ `task` replaces `step`
+- ✅ `main` replaces implicit `workflow`
+- ✅ Imperative control flow works
+- ✅ Organic function abstraction is viable
+
+### No Neural Complexity Yet
+By using a **purely symbolic task**, this test isolates synthesis validation from LLM execution complexity:
+- No LLM API calls to fail
+- No neural task instruction parsing
+- No MCP server connections
+- Just pure: synthesize → execute → output

data/synth/001/output.log

@@ -1,15 +1,15 @@
-📁 /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)
-· 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!"})
+⚬ 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)
+⚬ 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
+✔ Agent completed successfully
+
 

data/synth/002/Makefile

@@ -0,0 +1,12 @@
+.PHONY: synthesize exec help
+
+help:
+	@echo "Synthesis Test Targets:"
+	@echo "  make synthesize         - Generate agent.rb using default model"
+	@echo "  make exec                - Execute agent.rb locally with bundle exec"
+
+synthesize:
+	cat agent.txt | bundle exec ../../bin/aictl system synthesize --raw | tee agent.rb
+
+exec:
+	cat agent.rb | bundle exec ../../bin/aictl system exec | tee output.log