legate 0.1.0

data/lib/legate/cli/output_helper.rb

@@ -0,0 +1,108 @@
+# File: lib/legate/cli/output_helper.rb
+# frozen_string_literal: true
+
+require 'json'
+
+module Legate
+  module CLI
+    # Helper module for CLI output control.
+    # Provides methods to conditionally output status messages and format results
+    # based on --quiet and --json flags.
+    module OutputHelper
+      # Write status/progress message (suppressed in quiet or json mode)
+      # @param message [String] The status message to display
+      # @param color [Symbol, nil] Optional color for Thor's say method
+      def status_message(message, color = nil)
+        return if quiet_mode?
+
+        say message, color
+      end
+
+      # Output final result (JSON format in --json mode, otherwise uses format_method or default)
+      # @param data [Object] The result data to output
+      # @param metadata [Hash] Additional metadata to include (e.g., session_id)
+      # @param format_method [Symbol] Method name to call for human-friendly formatting
+      def output_result(data, metadata: {}, format_method: nil)
+        if json_mode?
+          output_json(data, metadata)
+        elsif format_method && respond_to?(format_method, true)
+          send(format_method, data)
+        else
+          say data.inspect
+        end
+      end
+
+      # Output error (JSON format in --json mode, otherwise text to stderr)
+      # @param error [Exception, String] The error to output
+      # @param metadata [Hash] Additional metadata to include
+      def output_error(error, metadata: {})
+        if json_mode?
+          error_data = {
+            status: 'error',
+            error_class: error.is_a?(Exception) ? error.class.name : 'Error',
+            error_message: error.is_a?(Exception) ? error.message : error.to_s
+          }
+          error_data.merge!(metadata) unless metadata.empty?
+          puts JSON.generate(error_data)
+        else
+          message = error.is_a?(Exception) ? "#{error.class} - #{error.message}" : error.to_s
+          say message, :red
+        end
+      end
+
+      private
+
+      # Check if quiet mode is enabled (--quiet or --json)
+      # Thor options may use string or symbol keys depending on how they're accessed
+      def quiet_mode?
+        options['quiet'] || options[:quiet] || options['json'] || options[:json]
+      end
+
+      # Check if JSON output mode is enabled
+      def json_mode?
+        options['json'] || options[:json]
+      end
+
+      # Output data as JSON
+      def output_json(data, metadata)
+        result = normalize_for_json(data)
+        output = metadata.empty? ? result : metadata.merge(result: result)
+        puts JSON.generate(output)
+      end
+
+      # Normalize various data types to JSON-serializable format
+      def normalize_for_json(data)
+        case data
+        when Legate::Event
+          normalize_event(data)
+        when Hash
+          normalize_hash(data)
+        when Array
+          data.map { |item| normalize_for_json(item) }
+        else
+          data
+        end
+      end
+
+      def normalize_event(event)
+        {
+          role: event.role.to_s,
+          content: normalize_for_json(event.content),
+          tool_name: event.tool_name&.to_s,
+          timestamp: event.timestamp
+        }.compact
+      end
+
+      def normalize_hash(hash)
+        hash.transform_keys(&:to_s).transform_values do |v|
+          case v
+          when Symbol then v.to_s
+          when Hash then normalize_hash(v)
+          when Array then v.map { |item| normalize_for_json(item) }
+          else v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legate/cli/session_commands.rb

@@ -0,0 +1,138 @@
+# File: lib/legate/cli/session_commands.rb
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'base_command'
+require 'json'
+require_relative '../session'
+require_relative '../session_service/in_memory'
+
+module Legate
+  module CLI
+    # CLI commands for session management
+    class SessionCommands < BaseCommand
+      desc 'list [APP_NAME] [USER_ID]', 'List all sessions or filter by app_name and/or user_id'
+      method_option :app_name, type: :string, desc: 'Filter sessions by application name'
+      method_option :user_id, type: :string, desc: 'Filter sessions by user ID'
+      def list(*args)
+        # Parse positional arguments if provided
+        app_name = options[:app_name] || args[0]
+        user_id = options[:user_id] || args[1]
+
+        session_service = Legate::SessionService::InMemory.new
+        sessions = session_service.list_sessions(app_name: app_name, user_id: user_id)
+
+        if sessions.empty?
+          say "No sessions found#{app_name ? " for app '#{app_name}'" : ''}#{user_id ? " and user '#{user_id}'" : ''}.",
+              :yellow
+          return
+        end
+
+        say "Found #{sessions.length} session(s):", :bold
+        sessions.each do |session|
+          created_at = session.created_at.strftime('%Y-%m-%d %H:%M:%S')
+          say "  ID: #{session.id}", :cyan
+          say "    App: #{session.app_name}"
+          say "    User: #{session.user_id}"
+          say "    Created: #{created_at}"
+          say "    Events: #{session.events.length}"
+          say ''
+        end
+      end
+
+      desc 'show SESSION_ID', 'Show details of a specific session including events'
+      def show(session_id)
+        session_service = Legate::SessionService::InMemory.new
+        session = session_service.get_session(session_id: session_id)
+
+        unless session
+          say "Session '#{session_id}' not found.", :red
+          return
+        end
+
+        created_at = session.created_at.strftime('%Y-%m-%d %H:%M:%S')
+        say 'Session Details:', :bold
+        say "  ID: #{session.id}", :cyan
+        say "  App: #{session.app_name}"
+        say "  User: #{session.user_id}"
+        say "  Created: #{created_at}"
+        say "  Events: #{session.events.length}"
+
+        if session.events.empty?
+          say "\nNo events in this session.", :yellow
+          return
+        end
+
+        say "\nEvents:", :bold
+        session.events.each_with_index do |event, index|
+          say "  #{index + 1}. [#{event.role}] #{event.content.inspect}"
+        end
+      end
+
+      desc 'delete SESSION_ID', 'Delete a specific session'
+      def delete(session_id)
+        session_service = Legate::SessionService::InMemory.new
+
+        # Check if session exists first
+        session = session_service.get_session(session_id: session_id)
+        unless session
+          say "Session '#{session_id}' not found.", :red
+          return
+        end
+
+        # Confirm deletion
+        if yes?("Are you sure you want to delete session '#{session_id}'? (y/n)")
+          if session_service.delete_session(session_id: session_id)
+            say "Session '#{session_id}' deleted successfully.", :green
+          else
+            say "Failed to delete session '#{session_id}'.", :red
+          end
+        else
+          say 'Deletion cancelled.', :yellow
+        end
+      end
+
+      desc 'execute AGENT_NAME TASK --session-id=SESSION_ID',
+           'Execute a task using an agent with a specific session'
+      method_option :session_id, type: :string, desc: 'ID of an existing session to use'
+      method_option :user_id, type: :string, default: 'cli_user', desc: 'User ID for the session'
+      def execute(agent_name, task)
+        # First, check if the agent exists in the GlobalDefinitionRegistry
+        name_sym = agent_name.to_sym
+        agent_definition = Legate::GlobalDefinitionRegistry.find(name_sym)
+
+        unless agent_definition
+          say "Error: Agent definition '#{agent_name}' not found.", :red
+          exit(1)
+        end
+
+        # Use in-memory session service
+        session_service = Legate::SessionService::InMemory.new
+        session_id = options[:session_id]
+        legate_session = nil
+
+        if session_id
+          legate_session = session_service.get_session(session_id: session_id)
+          if legate_session
+            say "Using existing session: #{session_id}", :cyan
+          else
+            say "Warning: Session ID '#{session_id}' provided but not found. Starting a new session.", :yellow
+            session_id = nil # Force creation below
+          end
+        end
+
+        unless legate_session
+          # Create a new session
+          legate_session = session_service.create_session(app_name: agent_name, user_id: options[:user_id])
+          session_id = legate_session.id
+          say "Started new session: #{session_id}", :cyan
+        end
+
+        # Now execute the task using the agent_commands implementation
+        agent_commands = Legate::CLI::AgentCommands.new
+        agent_commands.invoke(:execute, [agent_name, task],
+                              { session_id: session_id, session_service: session_service })
+      end
+    end
+  end
+end

data/lib/legate/cli/skaffold_commands.rb

@@ -0,0 +1,223 @@
+# File: lib/legate/cli/skaffold_commands.rb
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'base_command'
+require 'fileutils'
+
+module Legate
+  module CLI
+    class SkaffoldCommands < BaseCommand
+      default_task :generate
+
+      desc 'generate [PROJECT_NAME]', 'Generate a new Legate project structure'
+      method_option :dir, type: :string, desc: 'Target directory (defaults to current or project_name)'
+
+      def generate(project_name = nil)
+        target_dir = options[:dir] || project_name || '.'
+        target_dir = File.expand_path(target_dir)
+
+        say "Skaffolding new Legate project in '#{target_dir}'...", :green
+
+        unless Dir.exist?(target_dir)
+          FileUtils.mkdir_p(target_dir)
+          say "Created directory: #{target_dir}", :cyan
+        end
+
+        # 1. Gemfile
+        create_file(File.join(target_dir, 'Gemfile'), <<~GEMFILE)
+          source 'https://rubygems.org'
+
+          gem 'legate'
+          gem 'dotenv' # For loading .env files
+          gem 'puma'   # App server for the Web UI
+
+          group :test do
+            gem 'rspec'
+          end
+        GEMFILE
+
+        # 2. config.ru
+        create_file(File.join(target_dir, 'config.ru'), <<~CONFIGRU)
+          # frozen_string_literal: true
+
+          require 'rubygems'
+          require 'bundler/setup'
+
+          # Load environment variables early
+          require 'dotenv/load' if File.exist?('.env')
+
+          require 'legate'
+
+          # Configure Legate
+          Legate.configure do |config|
+            # Set your global configuration here
+            # config.default_model_name = 'gemini-3.5-flash'
+          #{'  '}
+            # config.session_service = Legate::SessionService::InMemory.new
+          end
+
+          # Helper to recursively require files in specific directories
+          def recursive_require(base_dir, sub_dirs)
+            sub_dirs.each do |dir|
+              full_path = File.join(base_dir, dir)
+              next unless Dir.exist?(full_path)
+
+              Dir.glob(File.join(full_path, '**', '*.rb')).sort.each do |file|
+                 # Skip tests/specs and tools inside agent directories if loading agents
+                 next if file.include?('_spec.rb') || file.include?('_test.rb')
+                 next if dir.include?('agents') && file.include?('/tools/')
+
+                 begin
+                   require file
+                 rescue LoadError => e
+                   puts "WARN: Failed to load \#{file}: \#{e.message}"
+                 end
+              end
+            end
+          end
+
+          # Load Agents
+          recursive_require(__dir__, ['lib/agents', 'agents/lib/agents', 'agents'])
+
+          # Load Tools
+          recursive_require(__dir__, ['lib/tools', 'agents/lib/tools', 'tools'])
+
+          # Check for Legate configuration for webhooks
+          if Legate.config.respond_to?(:webhooks) && Legate.config.webhooks.listener_enabled
+            require 'legate/web/webhook_listener'
+            # Mount the webhook listener if enabled
+            map Legate.config.webhooks.base_path do
+              run Legate::Web::WebhookListener.new
+            end
+          end
+
+          # Run the Legate Web UI
+          require 'legate/web/app'
+          run Legate::Web::App.new
+        CONFIGRU
+
+        # 3. Agents Directory & Sample Agent
+        agents_dir = File.join(target_dir, 'agents')
+        FileUtils.mkdir_p(agents_dir)
+        create_file(File.join(agents_dir, 'hello_world_agent.rb'), <<~RUBY)
+          require 'legate'
+
+          Legate::Agent.define do |a|
+            a.name :hello_world
+            a.description "A friendly agent that helps you verify your setup."
+            a.instruction "You are a helpful assistant. When asked to say hello, you should reply enthusiastically."
+          #{'  '}
+            # Use built-in tools
+            a.use_tool :echo#{' '}
+            a.use_tool :sample_tool
+          #{'  '}
+            # a.model_name 'gemini-1.5-pro'
+          end
+        RUBY
+
+        # A real, useful starter agent built on the SSRF-safe HTTP tools.
+        create_file(File.join(agents_dir, 'research_assistant_agent.rb'), <<~RUBY)
+          require 'legate'
+
+          # A research assistant that can look things up on the web and reason about
+          # what it finds. It uses Legate's built-in, SSRF-safe HTTP tools — no extra
+          # setup required beyond a GOOGLE_API_KEY for the LLM.
+          Legate::Agent.define do |a|
+            a.name :research_assistant
+            a.description "Researches a question by fetching and reading web pages, then summarizes the findings."
+            a.instruction <<~INSTRUCTION
+              You are a thorough research assistant.
+
+              When given a question or topic:
+              1. Use read_webpage to fetch and read relevant pages the user provides
+                 or that you can construct URLs for (e.g. documentation or APIs).
+              2. Use http_request when you need a raw API response (JSON, status checks).
+              3. Use current_time when the answer depends on today's date.
+
+              Always cite the URLs you read, distinguish facts from inference, and say
+              clearly when a source could not be reached or did not answer the question.
+            INSTRUCTION
+
+            a.use_tool :read_webpage
+            a.use_tool :http_request
+            a.use_tool :current_time
+
+            # a.model_name 'gemini-1.5-pro'
+          end
+        RUBY
+
+        # 4. Tools Directory
+        tools_dir = File.join(target_dir, 'tools')
+        FileUtils.mkdir_p(tools_dir)
+        create_file(File.join(tools_dir, '.keep'), '')
+        create_file(File.join(tools_dir, 'sample_tool.rb'), <<~RUBY)
+          require 'legate/tool'
+
+          class SampleTool < Legate::Tool
+            tool_description "Greets a user by name."
+          #{'  '}
+            parameter :name,#{' '}
+                      type: :string,#{' '}
+                      description: "The name of the user to greet",#{' '}
+                      required: true
+
+            private
+
+            def perform_execution(params, _context)
+              name = params[:name] || params['name']
+              { status: :success, result: "Hello, \#{name}! This is a custom tool." }
+            end
+          end
+
+          Legate::GlobalToolManager.register_tool(SampleTool)
+        RUBY
+
+        # 5. .env.example
+        create_file(File.join(target_dir, '.env.example'), <<~ENV)
+          # Copy this to .env and set your values
+          GOOGLE_API_KEY=your_api_key_here
+          LEGATE_LOG_LEVEL=INFO
+        ENV
+
+        # 6. bin/console (Optional helper)
+        bin_dir = File.join(target_dir, 'bin')
+        FileUtils.mkdir_p(bin_dir)
+        console_path = File.join(bin_dir, 'console')
+        create_file(console_path, <<~RUBY)
+          #!/usr/bin/env ruby
+          require 'bundler/setup'
+          require 'irb'
+          require 'dotenv/load'
+          require 'legate'
+
+          # Load agents/tools
+          Dir[File.join(__dir__, '..', 'agents', '*.rb')].each { |file| require file }
+          Dir[File.join(__dir__, '..', 'tools', '*.rb')].each { |file| require file }
+
+          puts "Legate Console loaded."
+          IRB.start
+        RUBY
+        FileUtils.chmod(0o755, console_path)
+
+        say "\nSkaffolding complete!", :green
+        say 'Next steps:', :yellow
+        say "  1. cd #{target_dir}", :cyan
+        say '  2. cp .env.example .env (and configure it)', :cyan
+        say '  3. bundle install', :cyan
+        say '  4. bundle exec rackup (to start the Web UI)', :cyan
+      end
+
+      private
+
+      def create_file(path, content)
+        if File.exist?(path)
+          say "Skipping existing file: #{path}", :yellow
+        else
+          File.write(path, content)
+          say "Created file: #{path}", :green
+        end
+      end
+    end
+  end
+end