glancer 1.0.0

data/app/controllers/glancer/messages_controller.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Glancer
+  class MessagesController < Glancer::ApplicationController
+    def create
+      @chat    = Glancer::Chat.find(params[:chat_id])
+      @message = @chat.messages.create!(message_params.merge(role: :user))
+
+      # Placeholder written immediately; ProcessMessageJob fills it in async.
+      @response_message = @chat.messages.create!(
+        role: :assistant,
+        content: "",
+        code_type: "sql",
+        user_message: @message,
+        status: :processing
+      )
+
+      Glancer::AsyncRunner.call(@response_message.id, @message.content)
+
+      @chats = Glancer::Chat.order(created_at: :desc)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to glancer.chat_path(@chat) }
+      end
+    end
+
+    # Clients poll this endpoint every ~2 s while waiting for the async runner.
+    # Returns 204 while still processing; Turbo Stream when complete or failed.
+    # A hard timeout marks stale messages as failed so the UI doesn't loop forever.
+    PROCESSING_TIMEOUT_SECONDS = 300
+
+    def poll
+      @message = Glancer::Message.find(params[:id])
+
+      if (@message.processing? || @message.pending?) &&
+         @message.updated_at < PROCESSING_TIMEOUT_SECONDS.seconds.ago
+        @message.update!(content: "Request timed out. Please try again.", successful: false, status: :failed)
+      end
+
+      return head(:no_content) if @message.processing? || @message.pending?
+
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.replace(
+            "message-#{@message.id}",
+            partial: "glancer/messages/message",
+            locals: { message: @message }
+          )
+        end
+      end
+    end
+
+    def run_code
+      @message = Glancer::Message.find(params[:id])
+      custom_code = params[:custom_code].presence
+
+      if custom_code
+        if @message.code_type == "activerecord"
+          Glancer::Workflow::ARSanitizer.ensure_safe!(custom_code)
+          @message.update!(code: custom_code, user_edited_code: true)
+          @message.code_versions.create!(code: custom_code, source: :user_edited)
+          @data = Glancer::Workflow::ARExecutor.execute(@message.code, message_id: @message.id)
+        else
+          Glancer::Workflow::SQLSanitizer.ensure_safe!(custom_code)
+          @message.update!(code: custom_code, user_edited_code: true)
+          @message.code_versions.create!(code: custom_code, source: :user_edited)
+          @data = Glancer::Workflow::Executor.execute(@message.code, message_id: @message.id)
+        end
+      elsif @message.code_type == "activerecord"
+        @data = Glancer::Workflow::ARExecutor.execute(@message.code, message_id: @message.id)
+      else
+        @data = Glancer::Workflow::Executor.execute(@message.code, message_id: @message.id)
+      end
+
+      respond_to do |format|
+        format.turbo_stream do
+          if @data.is_a?(Hash) && @data[:error]
+            render turbo_stream: turbo_stream.update("results-#{@message.id}",
+                                                     partial: "glancer/messages/execution_error",
+                                                     locals: { error_message: @data[:message] })
+          else
+            chart_data = Glancer::ChartAnalyzer.analyze(@data)
+            render turbo_stream: turbo_stream.update("results-#{@message.id}",
+                                                     partial: "glancer/messages/data_table",
+                                                     locals: { data: @data, chart_data: chart_data })
+          end
+        end
+      end
+    end
+
+    def open_in_blazer
+      @message = Glancer::Message.find(params[:id])
+      blazer_path = Glancer.configuration.resolved_blazer_path
+
+      unless blazer_path.present? && defined?(Blazer::Query)
+        redirect_to glancer.root_path, alert: "Blazer não está disponível."
+        return
+      end
+
+      unless @message.code_type == "sql" || @message.code_type.nil?
+        redirect_to glancer.root_path, alert: "Only SQL queries can be opened in Blazer."
+        return
+      end
+
+      query = Blazer::Query.create!(
+        name: "Glancer: #{@message.user_message&.content&.truncate(60) || "Query"}",
+        statement: @message.code.strip
+      )
+
+      redirect_to "#{blazer_path}/queries/#{query.id}/edit", allow_other_host: true
+    rescue StandardError => e
+      Glancer::Utils::Logger.error("MessagesController", "Failed to create Blazer query: #{e.message}")
+      redirect_to glancer.root_path, alert: "Não foi possível criar a query no Blazer: #{e.message}"
+    end
+
+    def message_info
+      @message_for_info = begin
+        Glancer::Message.find(params[:id])
+      rescue StandardError
+        nil
+      end
+
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: [
+            turbo_stream.replace("message-info", partial: "glancer/messages/message_info",
+                                                 locals: { message_info: @message_for_info })
+          ]
+        end
+      end
+    end
+
+    private
+
+    def message_params
+      params.require(:message).permit(:content)
+    end
+
+    def format_response(result)
+      result[:content]
+    end
+  end
+end

data/app/controllers/glancer/schema_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Glancer
+  class SchemaController < Glancer::ApplicationController
+    layout "glancer/application"
+
+    def show
+      @chats = Glancer::Chat.order(created_at: :desc)
+      connection = ActiveRecord::Base.connection
+      @tables = connection.tables.sort.filter_map do |table_name|
+        next if %w[schema_migrations ar_internal_metadata].include?(table_name)
+
+        columns = connection.columns(table_name).map do |col|
+          { name: col.name, type: col.sql_type, null: col.null, default: col.default }
+        end
+
+        fks = begin
+          connection.foreign_keys(table_name).map do |fk|
+            { from_column: fk.column, to_table: fk.to_table, to_column: fk.primary_key }
+          end
+        rescue StandardError
+          []
+        end
+
+        { name: table_name, columns: columns, foreign_keys: fks }
+      end
+    end
+  end
+end

data/app/controllers/glancer/settings_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Glancer
+  class SettingsController < ApplicationController
+    layout "glancer/application"
+
+    def show
+      @chats = Glancer::Chat.order(created_at: :desc)
+      @settings = {
+        ui_language: Glancer::Setting.get("ui_language", default: "en"),
+        speech_language: Glancer::Setting.get("speech_language", default: "auto"),
+        custom_instructions: Glancer::Setting.get("custom_instructions", default: "")
+      }
+      @glancer_config = Glancer.configuration
+    end
+
+    def update
+      allowed = params.require(:settings).permit(:ui_language, :speech_language, :custom_instructions)
+      Glancer::Setting.store_many(allowed.to_h)
+      redirect_to glancer.settings_path, notice: t("glancer.settings.saved")
+    end
+  end
+end

data/app/helpers/glancer/application_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Glancer
+  module ApplicationHelper
+    # Returns the list of indexed table names once per request (memoized).
+    def glancer_table_names
+      @glancer_table_names ||= Glancer::Embedding
+                               .where(source_type: "schema")
+                               .pluck(:source_path)
+                               .filter_map { |p| p.split("#").last if p.include?("#") }
+                               .reject { |n| n == "foreign_keys" }
+                               .uniq
+    rescue StandardError
+      []
+    end
+  end
+end

data/app/jobs/glancer/application_job.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Glancer
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/glancer/process_message_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Glancer
+  class ProcessMessageJob < Glancer::ApplicationJob
+    queue_as :default
+
+    def perform(message_id, question)
+      message = Glancer::Message.find(message_id)
+      chat    = message.chat
+
+      message.update!(status: :processing)
+
+      result = Glancer::Workflow.run(chat.id, question)
+
+      cfg        = Glancer.configuration
+      used_model = "#{cfg.resolved_chat_provider}/#{cfg.resolved_chat_model}"
+
+      message.update!(
+        content: result[:content].to_s,
+        code: result[:code],
+        code_type: result[:code_type] || "sql",
+        successful: result[:successful],
+        llm_model: used_model,
+        enriched_question: result[:enriched_question],
+        status: :complete
+      )
+
+      message.code_versions.create!(code: message.code, source: :generated) if message.code.present?
+
+      # Generate chat title on the first user message
+      chat.update!(title: Glancer::Workflow::LLM.generate_title(question)) if chat.messages.where(role: :user).count == 1
+    rescue StandardError => e
+      Glancer::Utils::Logger.error("ProcessMessageJob", "Failed for message #{message_id}: #{e.message}")
+      message&.update!(content: e.message, successful: false, status: :failed)
+      raise
+    end
+  end
+end

data/app/models/glancer/audit.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Audit < ApplicationRecord
+    self.table_name = "glancer_audits"
+
+    belongs_to :message, class_name: "Glancer::Message", optional: true
+
+    validates :code, :adapter, :run_id, :executed_at, presence: true
+    validates :run_id, uniqueness: true
+  end
+end

data/app/models/glancer/chat.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Chat < ApplicationRecord
+    has_many :messages, class_name: "Glancer::Message", dependent: :destroy
+    validates :title, presence: true
+  end
+end

data/app/models/glancer/code_version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Glancer
+  class CodeVersion < ApplicationRecord
+    self.table_name = "glancer_code_versions"
+
+    belongs_to :message, class_name: "Glancer::Message"
+    enum :source, generated: "generated", user_edited: "user_edited"
+
+    validates :code, :source, presence: true
+  end
+end

data/app/models/glancer/embedding.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Embedding < ApplicationRecord
+  end
+end

data/app/models/glancer/message.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Message < ApplicationRecord
+    belongs_to :chat, class_name: "Glancer::Chat"
+    belongs_to :user_message, class_name: "Glancer::Message", optional: true
+    has_many :code_versions, class_name: "Glancer::CodeVersion", dependent: :destroy
+    has_many :audits, class_name: "Glancer::Audit", foreign_key: :message_id, dependent: :nullify
+
+    # Nullify self-referential FK before destroy to avoid MySQL constraint violation
+    # when the chat cascade reaches user messages before their assistant counterparts
+    before_destroy { self.class.where(user_message_id: id).update_all(user_message_id: nil) }
+    enum :role, user: "user", assistant: "assistant", system: "system"
+    enum :status, { pending: 0, processing: 1, complete: 2, failed: 3 }, default: :complete
+
+    # User messages always require content; assistant placeholders start empty.
+    validates :content, presence: true, if: :user?
+
+    def sql_result_json
+      JSON.parse(content || "[]")
+    rescue JSON::ParserError
+      []
+    end
+  end
+end

data/app/models/glancer/setting.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Glancer
+  class Setting < ApplicationRecord
+    self.table_name = "glancer_settings"
+
+    validates :key, presence: true, uniqueness: true
+
+    def self.get(key, default: nil)
+      find_by(key: key.to_s)&.value || default
+    end
+
+    def self.set(key, value)
+      record = find_or_initialize_by(key: key.to_s)
+      record.value = value.to_s
+      record.save!
+    end
+
+    def self.store_many(hash)
+      hash.each { |k, v| set(k, v) }
+    end
+  end
+end

data/app/models/glancer/sql_version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Glancer
+  # Deprecated: use Glancer::CodeVersion instead.
+  SqlVersion = CodeVersion
+end

data/app/views/glancer/_data/_importmap.json.erb

@@ -0,0 +1,7 @@
+{
+  "imports": {
+    "application": "/assets/glancer/application.js",
+    "@hotwired/turbo-rails": "https://cdn.jsdelivr.net/npm/@hotwired/turbo-rails/+esm",
+    "@hotwired/stimulus": "https://cdn.jsdelivr.net/npm/@hotwired/stimulus/+esm"
+  }
+}

data/app/views/glancer/chats/_chat_sidebar.html.erb

@@ -0,0 +1,2 @@
+<%# This partial is no longer used — the sidebar is rendered directly in the layout. %>
+<%# Kept as a stub to avoid missing partial errors from any cached turbo streams. %>

data/app/views/glancer/chats/_show.html.erb

@@ -0,0 +1,52 @@
+<% if chat %>
+  <div class="flex-1 flex flex-col min-h-0">
+    <div id="chat-messages"
+         class="flex-1 overflow-y-auto py-6 flex flex-col"
+         role="log"
+         aria-live="polite"
+         aria-label="Conversation messages">
+      <div id="messages-list" class="flex-1 flex flex-col max-w-3xl lg:max-w-4xl xl:max-w-5xl 2xl:max-w-6xl mx-auto px-4 space-y-6 w-full">
+      <% if messages.blank? %>
+        <div id="chat-empty-state" class="flex-1 flex flex-col items-center justify-center text-center">
+          <div class="w-14 h-14 rounded-2xl bg-primary-50 dark:bg-primary-950 flex items-center justify-center mb-4">
+            <svg class="w-7 h-7 text-primary-600 dark:text-primary-400" aria-hidden="true"><use href="#icon-database"/></svg>
+          </div>
+          <h2 class="text-lg font-semibold text-gray-700 dark:text-gray-200 mb-1"><%= t("glancer.chat.empty_title") %></h2>
+          <p class="text-sm text-gray-400 dark:text-gray-500 max-w-xs"><%= t("glancer.chat.empty_subtitle") %></p>
+        </div>
+      <% else %>
+        <% messages.each do |message| %>
+          <%= render "glancer/messages/message", message: message %>
+        <% end %>
+      <% end %>
+      </div><%# /messages-list %>
+    </div>
+
+    <div class="flex-shrink-0 bg-white dark:bg-gray-900 border-t border-gray-200 dark:border-gray-800 px-4 py-4">
+      <%= render "glancer/messages/form", chat: chat %>
+    </div>
+  </div>
+
+<% else %>
+  <%# Temporary chat — no DB record yet. Chat is created on first message send. %>
+  <div class="flex-1 flex flex-col min-h-0">
+    <div id="chat-messages"
+         class="flex-1 overflow-y-auto py-6 flex flex-col"
+         role="log"
+         aria-live="polite">
+      <div id="messages-list" class="flex-1 flex flex-col max-w-3xl lg:max-w-4xl xl:max-w-5xl 2xl:max-w-6xl mx-auto px-4 space-y-6 w-full">
+        <div id="chat-empty-state" class="flex-1 flex flex-col items-center justify-center text-center">
+          <div class="w-14 h-14 rounded-2xl bg-primary-50 dark:bg-primary-950 flex items-center justify-center mb-4">
+            <svg class="w-7 h-7 text-primary-600 dark:text-primary-400" aria-hidden="true"><use href="#icon-database"/></svg>
+          </div>
+          <h2 class="text-lg font-semibold text-gray-700 dark:text-gray-200 mb-1"><%= t("glancer.chat.empty_title") %></h2>
+          <p class="text-sm text-gray-400 dark:text-gray-500 max-w-xs"><%= t("glancer.chat.empty_subtitle") %></p>
+        </div>
+      </div><%# /messages-list %>
+    </div>
+
+    <div class="flex-shrink-0 bg-white dark:bg-gray-900 border-t border-gray-200 dark:border-gray-800 px-4 py-4">
+      <%= render "glancer/messages/temp_form" %>
+    </div>
+  </div>
+<% end %>

data/app/views/glancer/chats/_sidebar_chat_list.html.erb

@@ -0,0 +1,30 @@
+<div id="sidebar-chat-list" class="flex-1 overflow-y-auto px-2 py-1">
+  <% if @chats.blank? %>
+    <p class="px-3 py-6 text-xs text-center text-gray-400 dark:text-gray-500">No chats yet. Create one to get started.</p>
+  <% else %>
+    <% @chats.each do |c| %>
+      <div class="group relative flex items-center rounded-lg my-0.5 <%= c == @chat ? 'bg-primary-50 dark:bg-primary-950' : 'hover:bg-gray-100 dark:hover:bg-gray-800' %> transition-colors">
+        <%= link_to glancer.chat_path(c),
+            class: "flex items-center gap-2.5 flex-1 min-w-0 px-3 py-2.5",
+            data: { action: "click->chat#select", chat_id: c.id, turbo: "false" },
+            aria: { current: (c == @chat ? "page" : nil) } do %>
+          <svg class="w-3.5 h-3.5 flex-shrink-0 <%= c == @chat ? 'text-primary-600 dark:text-primary-400' : 'text-gray-400' %>" aria-hidden="true">
+            <use href="#icon-chat"/>
+          </svg>
+          <span class="truncate text-sm <%= c == @chat ? 'font-medium text-primary-700 dark:text-primary-300' : 'text-gray-700 dark:text-gray-300' %>">
+            <%= c.title %>
+          </span>
+        <% end %>
+
+        <div class="flex-shrink-0 pr-2 opacity-0 group-hover:opacity-100 transition-opacity">
+          <%= link_to glancer.chat_path(c),
+              class: "p-1 rounded text-gray-400 hover:text-red-500 dark:hover:text-red-400 transition-colors",
+              data: { turbo_method: :delete, turbo_confirm: "Delete this chat?" },
+              aria: { label: "Delete chat" } do %>
+            <svg class="w-3.5 h-3.5" aria-hidden="true"><use href="#icon-trash"/></svg>
+          <% end %>
+        </div>
+      </div>
+    <% end %>
+  <% end %>
+</div>

data/app/views/glancer/chats/index.html.erb

@@ -0,0 +1,10 @@
+<div class="flex h-full w-full">
+  <%= render "glancer/chats/chat_sidebar" %>
+  
+  <div id="main-content" class="flex-1 flex flex-col bg-white dark:bg-gray-900 relative">
+    <%= render "glancer/chats/show", 
+         chat: @chat || @chats.first,
+         chats: @chats,
+         messages: (@chat || @chats.first)&.messages || [] %>
+  </div>
+</div>

data/app/views/glancer/chats/show.html.erb

@@ -0,0 +1 @@
+<%# Layout renders the chat UI via _show partial using @chat / @chats instance variables %>