legate 0.1.0

data/lib/legate/web/routes/core_routes.rb

@@ -0,0 +1,111 @@
+# File: lib/legate/web/routes/core_routes.rb
+# frozen_string_literal: true
+
+module Legate
+  module Web
+    module CoreRoutes
+      def self.registered(app)
+        # GET / - Main welcome page with dashboard metrics.
+        app.get '/' do
+          logger.debug('GET / route handler entered (from CoreRoutes)')
+
+          # Compute dashboard metrics
+          definition_store = instance_variable_get(:@definition_store)
+          tool_manager = instance_variable_get(:@tool_manager)
+
+          @agent_count = 0
+          @running_count = 0
+          @tool_count = 0
+          @auth_scheme_count = 0
+
+          if definition_store
+            definitions = begin
+              definition_store.list_definitions
+            rescue StandardError
+              []
+            end
+            @agent_count = definitions.size
+          end
+          # Running count is based on in-memory @agents hash
+          active_agents_hash = instance_variable_get(:@agents)
+          @running_count = active_agents_hash&.size || 0
+
+          if tool_manager
+            @tool_count = begin
+              tool_manager.tools.size
+            rescue StandardError
+              0
+            end
+          end
+
+          # Count auth schemes (best-effort; the dashboard must never break).
+          # Was checking the wrong constant (Legate::Authentication::Manager),
+          # so this count never displayed.
+          @auth_scheme_count = begin
+            Legate::Auth::Manager.instance.schemes.size
+          rescue StandardError
+            0
+          end
+
+          # Fetch recent activity
+          @recent_activity = if defined?(Legate::ActivityLog)
+                               begin
+                                 Legate::ActivityLog.recent(8)
+                               rescue StandardError
+                                 []
+                               end
+                             else
+                               []
+                             end
+
+          slim :index
+        end
+
+        # GET /activity/recent - Returns recent activity HTML partial
+        app.get '/activity/recent' do
+          @recent_activity = if defined?(Legate::ActivityLog)
+                               begin
+                                 Legate::ActivityLog.recent(8)
+                               rescue StandardError
+                                 []
+                               end
+                             else
+                               []
+                             end
+
+          slim :_activity_list, layout: false
+        end
+
+        # GET /healthz - Standard health check endpoint.
+        app.get '/healthz' do
+          current_app_instance = self
+          definition_store = current_app_instance.instance_variable_get(:@definition_store)
+
+          store_ok = if definition_store
+                       definition_store.check_connection
+                     else
+                       true # No persistence configured (in-memory mode)
+                     end
+
+          unless store_ok
+            logger.error('Health check failed: Definition Store unavailable or connection failed (from CoreRoutes).')
+            status 503
+            body 'Service Unavailable (Persistence)'
+            return
+          end
+
+          status 200
+          body 'OK'
+        rescue Legate::DefinitionStore::StoreError => e
+          logger.error("Health check failed (from CoreRoutes): Store error - #{e.message}")
+          status 503
+          body 'Service Unavailable (Persistence Error)'
+        rescue StandardError => e # Catch other unexpected errors
+          logger.error("Health check failed (from CoreRoutes): Unexpected error - #{e.class}: #{e.message}")
+          status 503
+          body 'Service Unavailable (Internal)'
+        end
+      end
+    end
+  end
+end

data/lib/legate/web/routes/documentation_routes.rb

@@ -0,0 +1,220 @@
+# File: lib/legate/web/routes/documentation_routes.rb
+# frozen_string_literal: true
+
+require 'kramdown' # Required for markdown processing
+require 'kramdown-parser-gfm' # Required for GitHub Flavored Markdown
+require 'pathname' # For robust path operations
+
+module Legate
+  module Web
+    module DocumentationRoutes
+      module Helpers
+        def render_markdown(file_path)
+          public_docs_pathname = Pathname.new(File.expand_path(File.join(settings.root, 'public', 'docs')))
+          target_file_pathname = Pathname.new(File.expand_path(file_path))
+
+          # Check if the target file is within the public_docs_pathname directory
+          # and is an actual file that exists.
+          # The `ascend` method iterates upwards from the file to its parent directories.
+          # We check if any of these parent paths match our intended docs root.
+          is_within_docs_dir = false
+          target_file_pathname.ascend do |p|
+            if p == public_docs_pathname
+              is_within_docs_dir = true
+              break
+            end
+            break if p.root? # Stop if we reach the filesystem root
+          end
+
+          unless is_within_docs_dir && target_file_pathname.file? && target_file_pathname.exist?
+            logger.warn "Markdown render: Path not valid or file does not exist. Target: '#{target_file_pathname}', Expected base: '#{public_docs_pathname}'"
+            return nil
+          end
+
+          markdown_content = File.read(target_file_pathname.to_s, encoding: 'UTF-8')
+
+          # Configure Kramdown with enhanced rendering options - now using GFM
+          html = Kramdown::Document.new(
+            markdown_content,
+            input: 'GFM',               # GitHub Flavored Markdown
+            syntax_highlighter: nil,    # We'll apply our custom highlighting via CSS
+            hard_wrap: false            # Don't convert newlines to <br>
+          ).to_html
+
+          # Post-process HTML to add language tags to code blocks
+          process_code_blocks(html)
+        rescue Errno::ENOENT # Should be caught by File.exist? check now, but good fallback
+          logger.warn "Markdown file not found (render_markdown): #{target_file_pathname}"
+          nil
+        rescue StandardError => e
+          logger.error "Error rendering markdown for #{target_file_pathname}: #{e.message}"
+          logger.error e.backtrace.join("\n") # Add backtrace to help debugging
+          nil
+        end
+
+        # Process code blocks to add language classes and data attributes
+        def process_code_blocks(html)
+          # Find fenced code blocks with language specifications
+          html.gsub(%r{<pre><code\s+class="language-(\w+)">(.*?)</code></pre>}m) do |match|
+            language = ::Regexp.last_match(1)
+            code_content = ::Regexp.last_match(2)
+            # Replace with our enhanced version that adds data-lang attribute
+            %(<pre data-lang="#{language}"><code class="language-#{language}">#{code_content}</code></pre>)
+          end
+        end
+
+        def generate_summary(markdown_content, max_lines = 5)
+          return '' if markdown_content.nil? || markdown_content.empty?
+
+          lines = markdown_content.lines
+          summary_lines = []
+          non_empty_lines_count = 0
+          lines.each do |line|
+            stripped_line = line.strip
+            if !stripped_line.empty? && !stripped_line.start_with?('#') # Ignore headers for summary start
+              summary_lines << stripped_line
+              non_empty_lines_count += 1
+              break if non_empty_lines_count >= max_lines
+            elsif !summary_lines.empty? && stripped_line.empty? # Break on first blank line after content started
+              break
+            elsif summary_lines.empty? && stripped_line.start_with?('#') # Skip leading headers
+              next
+            end
+          end
+          summary_lines.join(' ').gsub(/\*\*|\*|_|`/, '') # Basic stripping of markdown
+        end
+      end # module Helpers
+
+      def self.registered(app)
+        app.helpers Helpers # Register the helpers for use in routes
+
+        # Route for Documentation Index (GET /docs)
+        app.get '/docs' do
+          logger.debug('--- GET /docs --- (DocumentationRoutes)')
+          docs_root_path = Pathname.new(File.join(settings.root, 'public', 'docs'))
+          logger.debug("Docs root resolved to: #{docs_root_path}")
+
+          categorized_documents = {}
+
+          begin
+            # Process files directly in docs_root_path first (General category)
+            general_docs = []
+            Dir.glob(File.join(docs_root_path, '*.md')).sort.each do |md_file_path|
+              pathname = Pathname.new(md_file_path)
+              next if pathname.directory? # Skip directories if any found by glob
+
+              filename_md = pathname.basename.to_s
+              filename_no_ext = pathname.basename('.md').to_s
+              title = filename_no_ext.gsub(/[-_]/, ' ').split.map(&:capitalize).join(' ')
+              file_content = File.read(md_file_path, encoding: 'UTF-8')
+              first_h1_match = file_content.match(/^#\s+(.+)$/)
+              title = first_h1_match[1].strip if first_h1_match
+              summary = generate_summary(file_content)
+
+              general_docs << {
+                title: title,
+                path: filename_no_ext, # Path relative to docs_root for linking
+                summary: summary
+              }
+            end
+            categorized_documents['General'] = general_docs if general_docs.any?
+
+            # Process subdirectories for categories
+            Dir.glob(File.join(docs_root_path, '*/')).sort.each do |dir_path|
+              category_pathname = Pathname.new(dir_path)
+              category_name = category_pathname.basename.to_s.gsub(/[-_]/, ' ').split.map(&:capitalize).join(' ')
+              category_docs = []
+
+              Dir.glob(File.join(category_pathname, '*.md')).sort.each do |md_file_path|
+                pathname = Pathname.new(md_file_path)
+                filename_md = pathname.basename.to_s
+                filename_no_ext = pathname.basename('.md').to_s
+                full_relative_path = "#{category_pathname.basename}/#{filename_no_ext}"
+
+                title = filename_no_ext.gsub(/[-_]/, ' ').split.map(&:capitalize).join(' ')
+                file_content = File.read(md_file_path, encoding: 'UTF-8')
+                first_h1_match = file_content.match(/^#\s+(.+)$/)
+                title = first_h1_match[1].strip if first_h1_match
+                summary = generate_summary(file_content)
+
+                category_docs << {
+                  title: title,
+                  path: full_relative_path, # Path includes category dir
+                  summary: summary
+                }
+              end
+              categorized_documents[category_name] = category_docs if category_docs.any?
+            end
+
+            logger.warn("No markdown files or categories found in #{docs_root_path}") if categorized_documents.empty?
+          rescue StandardError => e
+            logger.error("Error scanning documentation directory: #{e.message}")
+            logger.error(e.backtrace.first(5).join("\n"))
+          end
+
+          instance_variable_set(:@categorized_documents, categorized_documents)
+          logger.debug("Setting @categorized_documents with #{categorized_documents.keys.count} categories.")
+          logger.debug("Content of @categorized_documents: #{@categorized_documents.inspect}")
+
+          slim :docs_index
+        end
+
+        # Route for Displaying a Single Document (GET /docs/*)
+        # The splat parameter will capture the category/filename path
+        app.get '/docs/*' do |path_splat|
+          logger.debug("GET /docs/#{path_splat} - Entered (from DocumentationRoutes)")
+
+          # Sanitize path_splat: allow alphanumeric, underscore, hyphen, and forward slash for path
+          # Remove leading/trailing slashes and protect against directory traversal
+          sane_path = path_splat.gsub(%r{^/+|/+$}, '').gsub(%r{\.{2}/}, '')
+          sane_path.gsub!(%r{[^0-9a-zA-Z_\-/]}, '') # Allow alphanumeric, _, -, /
+
+          if sane_path.empty?
+            logger.warn("Attempt to access doc with invalid path: '#{path_splat}'")
+            halt 404, slim(:error_404, locals: { title: 'Document Not Found', message: 'Invalid document path.' })
+          end
+
+          # Construct the full file path
+          # Ensure it's .md, even if not explicitly in splat, for direct access attempts
+          file_path_to_check = sane_path.end_with?('.md') ? sane_path : "#{sane_path}.md"
+          full_file_path = File.join(settings.root, 'public', 'docs', file_path_to_check)
+          logger.debug("Attempting to access document at: #{full_file_path}")
+
+          # The render_markdown helper already performs security checks to ensure the file is within 'public/docs'
+          # and is a .md file.
+
+          begin
+            markdown_html = render_markdown(full_file_path) # render_markdown expects absolute path
+
+            if markdown_html.nil?
+              logger.warn("Documentation file not found or rendering failed: #{full_file_path}")
+              halt 404,
+                   slim(:error_404,
+                        locals: { title: 'Document Not Found',
+                                  message: "Document '#{sane_path}' not found or could not be rendered." })
+            end
+
+            instance_variable_set(:@doc_html_content, markdown_html)
+
+            # Try to extract title from H1 in markdown content
+            # This requires reading the file again, or passing content from render_markdown if it returned it
+            # For now, let's re-read for title extraction consistency.
+            doc_title_for_view = sane_path.split('/').last.gsub(/[-_]/, ' ').split.map(&:capitalize).join(' ') # Default title
+            if File.exist?(full_file_path)
+              markdown_content_for_title = File.read(full_file_path, encoding: 'UTF-8')
+              first_h1_match = markdown_content_for_title.match(/^#\s+(.+)$/)
+              doc_title_for_view = first_h1_match[1].strip if first_h1_match
+            end
+            instance_variable_set(:@doc_title, doc_title_for_view)
+
+            slim :docs_show
+          rescue StandardError => e
+            logger.error("Error processing document #{sane_path}: #{e.message}")
+            logger.error(e.backtrace.join("\n"))
+            halt 500, 'Error displaying document.'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legate/web/routes/tool_generator_routes.rb

@@ -0,0 +1,81 @@
+# File: lib/legate/web/routes/tool_generator_routes.rb
+# frozen_string_literal: true
+
+require_relative '../../generators/tool_generator'
+require_relative '../../generators/runtime_tool_loader'
+
+module Legate
+  module Web
+    # Routes for AI-powered tool code generation. Delegates to
+    # Legate::Generators::ToolGenerator so the web path shares the exact
+    # generation logic AND the CodeValidator safety check used by the CLI
+    # (the route must not reimplement either).
+    module ToolGeneratorRoutes
+      def self.registered(app)
+        # POST /tools/generate - Generate tool class code from natural language
+        app.post '/tools/generate' do
+          content_type :json
+
+          begin
+            request.body.rewind
+            body = JSON.parse(request.body.read)
+          rescue JSON::ParserError => e
+            halt 400, json(error: "Invalid JSON: #{e.message}")
+          end
+
+          begin
+            result = Legate::Generators::ToolGenerator.generate(description: body['description'].to_s.strip)
+            logger.info("Successfully generated tool code (name: #{result[:suggested_name]}, type: #{result[:tool_type]})")
+            json(result)
+          rescue Legate::Generators::ToolGenerator::ApiKeyMissingError => e
+            halt 503, json(error: e.message)
+          rescue Legate::Generators::ToolGenerator::ApiError => e
+            logger.error("Gemini API error during tool generation: #{e.message}")
+            halt 503, json(error: 'AI service communication error. Please try again.')
+          rescue Legate::Generators::ToolGenerator::GenerationError => e
+            # Covers validation failures, empty responses, and unsafe generated
+            # code rejected by CodeValidator.
+            halt 400, json(error: e.message)
+          rescue StandardError => e
+            logger.error("Unexpected error during tool generation: #{e.class} - #{e.message}")
+            halt 500, json(error: 'Generation failed. Please try again.')
+          end
+        end
+
+        # POST /tools/install - Load a generated custom tool into the RUNNING process.
+        # SECURITY: executes LLM-generated Ruby. Gated by config + explicit confirm +
+        # server-side re-validation (see RuntimeToolLoader). Writes tools/<name>.rb.
+        app.post '/tools/install' do
+          content_type :json
+
+          halt 403, json(error: 'Runtime tool loading is disabled in this environment. Use Download instead, place the file in tools/, and restart.') unless Legate::Generators::RuntimeToolLoader.enabled?
+
+          begin
+            request.body.rewind
+            body = JSON.parse(request.body.read)
+          rescue JSON::ParserError => e
+            halt 400, json(error: "Invalid JSON: #{e.message}")
+          end
+
+          # Require an explicit confirmation that the user accepts running this code.
+          halt 400, json(error: 'Confirmation required to install a tool.') unless body['confirm'] == true
+
+          source = body['code'].to_s
+          halt 400, json(error: 'No tool code provided.') if source.strip.empty?
+
+          result = Legate::Generators::RuntimeToolLoader.load_source!(
+            source, suggested_name: body['suggested_name'].to_s
+          )
+
+          if result[:ok]
+            logger.info("Runtime-loaded custom tool '#{result[:tool_name]}' -> #{result[:path]}")
+            json(ok: true, tool_name: result[:tool_name])
+          else
+            logger.warn("Runtime tool install rejected: #{result[:error]}")
+            halt 422, json(error: result[:error])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legate/web/routes/tools_ui_routes.rb

@@ -0,0 +1,207 @@
+# File: lib/legate/web/routes/tools_ui_routes.rb
+# frozen_string_literal: true
+
+module Legate
+  module Web
+    module ToolsUIRoutes
+      def self.registered(app)
+        # GET /tools - Display available native and MCP tools
+        app.get '/tools' do
+          logger.info('GET /tools route handler entered (from ToolsUIRoutes)')
+
+          current_app_instance = self
+          definition_store = current_app_instance.instance_variable_get(:@definition_store)
+
+          # 1. Get Native Tools (already formatted)
+          native_tools_metadata = Legate::GlobalToolManager.list_all_tools.map do |tool_meta|
+            parameters_array = []
+            if tool_meta[:parameters].is_a?(Hash) && !tool_meta[:parameters].empty?
+              tool_meta[:parameters].each do |param_name, details|
+                parameters_array << {
+                  name: param_name,
+                  type: details[:type],
+                  description: details[:description],
+                  required: details[:required]
+                }
+              end
+            end
+            tool_meta.merge(parameters: parameters_array, source: :native, source_detail: 'Native')
+          end
+
+          # 2. Get MCP Tools
+          all_mcp_configs = []
+          if definition_store
+            begin
+              agent_summaries = definition_store.list_definitions
+              all_mcp_configs = agent_summaries.flat_map do |summary|
+                mcp_json = summary[:mcp_servers_json]
+                if mcp_json && !mcp_json.empty? && mcp_json != '[]'
+                  JSON.parse(mcp_json)
+                else
+                  []
+                end
+              end.uniq
+            rescue JSON::ParserError => e
+              logger.error("Error parsing MCP JSON for /tools (from ToolsUIRoutes): #{e.message}")
+            rescue Legate::DefinitionStore::StoreError => e
+              logger.error("Store error fetching agent definitions for /tools (from ToolsUIRoutes): #{e.message}")
+            end
+          else
+            logger.warn('Definition store not available for MCP tool discovery in /tools (from ToolsUIRoutes)')
+          end
+
+          mcp_tool_fetch_results = fetch_mcp_tools(all_mcp_configs || [])
+
+          processed_mcp_tools_metadata = []
+          mcp_tool_fetch_results.each do |result|
+            next unless result[:status] == :success && result[:tools]
+
+            result[:tools].each do |mcp_tool_schema|
+              parameters = []
+              begin
+                input_schema = mcp_tool_schema[:inputSchema]
+                if input_schema&.is_a?(Hash)
+                  properties = input_schema['properties'] || {}
+                  required_props = input_schema['required'] || []
+                  parameters = Legate::Mcp::Util::SchemaConverter.json_to_legate(properties, required_props)
+                end
+              rescue StandardError => e
+                logger.error("Error converting MCP schema for tool '#{mcp_tool_schema[:name]}' in /tools (from ToolsUIRoutes): #{e.message}")
+              end
+              processed_mcp_tools_metadata << {
+                name: mcp_tool_schema[:name].to_sym,
+                description: mcp_tool_schema[:description] || '',
+                parameters: parameters,
+                source: :mcp,
+                source_detail: "MCP (#{result[:server]})"
+              }
+            end
+          end
+
+          # 3. Set @native_tools for the current view requirements
+          instance_variable_set(:@native_tools, native_tools_metadata.sort_by { |t| t[:name].to_s })
+
+          # For future enhancement of tools.slim to show all tools:
+          combined_tools_map = {}
+          native_tools_metadata.each { |tool| combined_tools_map[tool[:name]] = tool }
+          processed_mcp_tools_metadata.each { |tool| combined_tools_map[tool[:name]] ||= tool }
+          instance_variable_set(:@all_tools_list, combined_tools_map.values.sort_by { |t| t[:name].to_s })
+          instance_variable_set(:@mcp_tool_results_for_view, mcp_tool_fetch_results) # For displaying fetch errors
+
+          slim :tools
+        end
+
+        # GET /tools/:name - Display tool detail page (native or MCP)
+        app.get '/tools/:name' do |name|
+          logger.info("GET /tools/#{name} route handler entered (from ToolsUIRoutes)")
+          tool_name_sym = name.to_sym
+
+          current_app_instance = self
+          definition_store = current_app_instance.instance_variable_get(:@definition_store)
+
+          # 1. Try to find in native tools
+          native_tool_metadata = Legate::GlobalToolManager.list_all_tools.find { |t| t[:name] == tool_name_sym }
+          tool_to_display = nil
+
+          if native_tool_metadata
+            parameters_array = []
+            if native_tool_metadata[:parameters].is_a?(Hash) && !native_tool_metadata[:parameters].empty?
+              native_tool_metadata[:parameters].each do |param_name, details|
+                parameters_array << {
+                  name: param_name,
+                  type: details[:type],
+                  description: details[:description],
+                  required: details[:required]
+                }
+              end
+            end
+            tool_to_display = native_tool_metadata.merge(parameters: parameters_array, source: :native,
+                                                         source_detail: 'Native')
+          else
+            # 2. Not native, try to find in MCP tools
+            all_mcp_configs = []
+            if definition_store
+              begin
+                agent_summaries = definition_store.list_definitions
+                all_mcp_configs = agent_summaries.flat_map do |summary|
+                  mcp_json = summary[:mcp_servers_json]
+                  if mcp_json && !mcp_json.empty? && mcp_json != '[]'
+                    JSON.parse(mcp_json)
+                  else
+                    []
+                  end
+                end.uniq
+              rescue JSON::ParserError => e
+                logger.error("Error parsing MCP JSON for /tools/#{name} (from ToolsUIRoutes): #{e.message}")
+              rescue Legate::DefinitionStore::StoreError => e
+                logger.error("Store error fetching agent definitions for /tools/#{name} (from ToolsUIRoutes): #{e.message}")
+              end
+            else
+              logger.warn("Definition store not available for MCP tool discovery in /tools/#{name} (from ToolsUIRoutes)")
+            end
+
+            mcp_tool_fetch_results = fetch_mcp_tools(all_mcp_configs || [])
+
+            mcp_tool_fetch_results.each do |result|
+              next unless result[:status] == :success && result[:tools]
+
+              tool_data = result[:tools].find { |t| t[:name].to_s == name || t[:name].to_sym == tool_name_sym }
+              next unless tool_data
+
+              parameters = []
+              begin
+                input_schema = tool_data[:inputSchema]
+                if input_schema&.is_a?(Hash)
+                  properties = input_schema['properties'] || {}
+                  required_props = input_schema['required'] || []
+                  parameters = Legate::Mcp::Util::SchemaConverter.json_to_legate(properties, required_props)
+                end
+              rescue StandardError => e
+                logger.error("Error converting MCP schema for tool '#{tool_data[:name]}' in /tools/#{name} (from ToolsUIRoutes): #{e.message}")
+              end
+              tool_to_display = {
+                name: tool_data[:name].to_sym,
+                description: tool_data[:description] || '',
+                parameters: parameters,
+                source: :mcp,
+                source_detail: "MCP (#{result[:server]})"
+              }
+              break
+            end
+          end
+
+          if tool_to_display
+            instance_variable_set(:@tool, tool_to_display)
+            logger.debug("Found tool metadata for '#{name}': #{tool_to_display.inspect}")
+            slim :tool_detail
+          else
+            logger.warn("Tool '#{name}' not found anywhere (from ToolsUIRoutes).")
+            status 404
+            slim(:error_404,
+                 locals: { title: 'Tool Not Found', message: "Tool definition for '#{name}' not found." })
+          end
+        end
+
+        # GET /tools/:name/download - Download native tool as Ruby file
+        app.get '/tools/:name/download' do |name|
+          logger.info("Received request to download tool '#{name}' as Ruby file")
+          tool_name_sym = name.to_sym
+
+          # Check if it's a native tool
+          tool_class = Legate::GlobalToolManager.find_class(tool_name_sym)
+          halt 400, 'Only native tools can be downloaded as Ruby files. MCP tools cannot be exported.' unless tool_class
+
+          # Generate Ruby code
+          require 'legate/tool_code_generator'
+          ruby_code = Legate::ToolCodeGenerator.generate(tool_name_sym)
+
+          halt 404, 'Tool not found or could not generate code.' unless ruby_code
+
+          content_type 'application/x-ruby'
+          attachment "#{name.to_s.gsub(/[^a-zA-Z0-9_-]/, '_')}.rb"
+          ruby_code
+        end
+      end
+    end
+  end
+end