parapet-rails 0.1.0

data/app/controllers/parapet/files_controller.rb

@@ -0,0 +1,208 @@
+module Parapet
+  class FilesController < ApplicationController
+    def index
+      # Use Engine.root to find the mock file stored within the engine
+      mock_path = Parapet::Engine.root.join("storage", "seeds-project-explorer.json")
+
+      if File.exist?(mock_path)
+        render json: File.read(mock_path)
+      else
+        # Fallback to real filesystem scanning
+        root_path = Parapet::Engine.root
+        render json: build_tree(root_path)
+      end
+    end
+
+    def show
+      raw_path = params[:path].to_s
+
+      # Security: Get absolute root path
+      root_path = File.expand_path(Parapet::Engine.root.to_s)
+
+      # On Windows, a path may arrive as an absolute path with a drive letter
+      if Gem.win_platform? && raw_path.match?(/^[A-Z]:/i)
+        full_path = File.expand_path(raw_path)
+      else
+        # Strip leading slash to ensure it's relative to root_path
+        relative_path = raw_path.sub(/^\//, '')
+        full_path = File.expand_path(File.join(root_path, relative_path))
+      end
+
+      # Fallback: Deduplication logic for cases like spec/spec/file.rb
+      if !File.exist?(full_path)
+        # Try to remove duplicated first segment if it exists
+        relative_path = raw_path.sub(/^\//, '')
+        parts = relative_path.split('/')
+        if parts.size > 1 && parts[0] == parts[1]
+          alternate_relative = parts[1..-1].join('/')
+          alternate_path = File.expand_path(File.join(root_path, alternate_relative))
+          if File.exist?(alternate_path)
+            Rails.logger.warn "Parapet Explorer: Found file via de-duplication: #{alternate_path}"
+            full_path = alternate_path
+          end
+        end
+      end
+
+      # Final security and existence check
+      if full_path.start_with?(root_path)
+        # Timing mitigation (Windows/AV suspected; the cause was never demonstrated): retry once
+        # if the file is not found. The retry is logged when it actually finds the file, so we
+        # learn whether it is ever needed. If that line never appears in the log, remove it.
+        exists = File.exist?(full_path)
+        if !exists && !File.directory?(full_path)
+          sleep 0.05
+          exists = File.exist?(full_path)
+          Rails.logger.warn "Parapet Files: #{full_path} was not found on the first check but was found on the retry (timing mitigation was needed)" if exists
+        end
+
+        if exists && !File.directory?(full_path)
+          content = File.read(full_path)
+          render json: { content: content, path: params[:path] }
+        else
+          render json: {
+            content: "# Error: Access Denied or File Not Found\n# Target: #{full_path}\n# Root: #{root_path}",
+            path: params[:path]
+          }, status: :not_found
+        end
+      else
+        render json: { error: "Access Denied" }, status: :forbidden
+      end
+    end
+
+
+    def update
+      relative_path = params[:path].to_s.sub(/^\//, '')
+      root_path = File.expand_path(Parapet::Engine.root.to_s)
+      full_path = File.expand_path(File.join(root_path, relative_path))
+
+      # Security check: Ensure we are within root
+      unless full_path.start_with?(root_path)
+        render json: { error: "Access Denied" }, status: :forbidden
+        return
+      end
+
+      begin
+        Parapet::FileSaveService.new(
+          user: current_user,
+          full_path: full_path,
+          relative_path: relative_path,
+          content: params[:content]
+        ).save!
+        render json: {
+          status: "success",
+          path: params[:path],
+          flash: { notice: "File persisted successfully to #{params[:path]}" }
+        }
+      rescue => e
+        render json: {
+          error: e.message,
+          flash: { alert: "Failed to persist file: #{e.message}" }
+        }, status: :internal_server_error
+      end
+    end
+
+    def move
+      old_relative = params[:old_path].to_s.sub(/^\//, '')
+      new_relative = params[:new_path].to_s.sub(/^\//, '')
+      root_path = File.expand_path(Parapet::Engine.root.to_s)
+
+      old_full = File.expand_path(File.join(root_path, old_relative))
+      new_full = File.expand_path(File.join(root_path, new_relative))
+
+      # Security check
+      unless old_full.start_with?(root_path) && new_full.start_with?(root_path)
+        render json: { error: "Access Denied" }, status: :forbidden
+        return
+      end
+
+      if File.exist?(old_full)
+        begin
+          # Ensure target directory exists
+          FileUtils.mkdir_p(File.dirname(new_full))
+          File.rename(old_full, new_full)
+          render json: {
+            status: "success",
+            old_path: params[:old_path],
+            new_path: params[:new_path],
+            flash: { notice: "Renamed: #{File.basename(old_full)} -> #{File.basename(new_full)}" }
+          }
+        rescue => e
+          render json: { error: e.message }, status: :internal_server_error
+        end
+      else
+        render json: { error: "File not found" }, status: :not_found
+      end
+    end
+
+    def assets
+      root_path = Parapet::Engine.root.to_s
+      image_extensions = %w[svg png jpg jpeg webp gif]
+
+      assets = []
+      begin
+        Dir.glob(File.join(root_path, "app/assets/images/**/*.{#{image_extensions.join(',')}}")).each do |path|
+          rel_path = path.sub(root_path, '').sub(/^[\\\/]/, '').gsub('\\', '/')
+          assets << {
+            name: File.basename(path),
+            path: rel_path,
+            url: (view_context.asset_path("parapet/#{rel_path.sub('app/assets/images/parapet/', '')}") rescue rel_path)
+          }
+        end
+      rescue => e
+        Rails.logger.error "Parapet Assets Error: #{e.message}"
+      end
+
+      render json: assets
+    end
+
+    private
+
+    def build_tree(path)
+      root_path = Parapet::Engine.root.to_s
+      name = File.basename(path)
+      return nil if name.start_with?('.') && name != '.'
+
+      # Basic ignore list for performance
+      ignored = %w[node_modules vendor .git tmp log .bundle .zencoder]
+      return nil if ignored.include?(name)
+
+      # Editable assets for the Style Workbench
+      allowed_extensions = %w[erb scss css rb]
+
+      # Calculate relative path without leading slash
+      rel_path = path.to_s.sub(root_path, '').sub(/^[\\\/]/, '').gsub('\\', '/')
+
+      if File.directory?(path)
+        children = Dir.children(path).sort.map { |child| build_tree(File.join(path, child)) }.compact
+
+        # Only return directory if it has children (prune empty branches)
+        return nil if children.empty?
+
+        {
+          name: name == '.' ? 'root' : name,
+          type: 'directory',
+          path: rel_path.empty? ? '/' : rel_path,
+          children: children
+        }
+      else
+        ext = File.extname(path).delete('.')
+
+        # Strict filtering for relevant file types
+        # Note: .html.erb has ext "erb"
+        return nil unless allowed_extensions.include?(ext)
+
+        # If it's .rb, ensure it's in a relevant directory (optional, but safer)
+        # For now, we'll keep all .rb (presenters/models) as they might contain logic
+
+        {
+          name: name,
+          type: 'file',
+          path: rel_path,
+          ext: ext
+        }
+      end
+    rescue Errno::EACCES
+      nil
+    end
+  end
+end

data/app/controllers/parapet/footers_controller.rb

@@ -0,0 +1,24 @@
+module Parapet
+  class FootersController < ApplicationController
+    SUITE_MAP = {
+      "tests"     => "parapet/shared/footer_tests",
+      "styles"    => "parapet/shared/footer_styles",
+      "state"     => "parapet/shared/footer_state",
+      "pulse"     => "parapet/shared/footer_pulse",
+      "traffic"   => "parapet/shared/footer_traffic",
+      "languages" => "parapet/shared/footer_languages",
+      "ideas"     => "parapet/shared/footer_ideas"
+    }.freeze
+
+    def show
+      suite = params[:suite]
+      partial = SUITE_MAP[suite]
+
+      if partial
+        render partial: partial
+      else
+        render plain: "Footer not found", status: :not_found
+      end
+    end
+  end
+end

data/app/controllers/parapet/intentions_suite/dashboard_controller.rb

@@ -0,0 +1,10 @@
+module Parapet
+  module IntentionsSuite
+    class DashboardController < Parapet::BaseController
+      def index
+        @active_suite = 'intentions'
+        render "parapet/dashboards/index"
+      end
+    end
+  end
+end

data/app/controllers/parapet/landing_controller.rb

@@ -0,0 +1,14 @@
+module Parapet
+  class LandingController < ApplicationController
+    layout 'parapet/landing'
+
+    def index
+      render 'parapet/index'
+    end
+
+    def login
+      # Placeholder for login action logic
+      redirect_to css_suite_path
+    end
+  end
+end

data/app/controllers/parapet/monitor_suite/dashboard_controller.rb

@@ -0,0 +1,10 @@
+module Parapet
+  module MonitorSuite
+    class DashboardController < Parapet::BaseController
+      def index
+        @active_suite = 'monitor'
+        render "parapet/dashboards/index"
+      end
+    end
+  end
+end

data/app/controllers/parapet/pm_suite/publish_controller.rb

@@ -0,0 +1,16 @@
+module Parapet
+  module PmSuite
+    class PublishController < ApplicationController
+      def create
+        result = Parapet::PublishGate.new(user: current_user).run
+
+        render json: {
+          status: result.run_history.status,
+          exit_code: result.run_history.exit_code,
+          raw_output: result.run_history.raw_output,
+          run_history_id: result.run_history.id
+        }
+      end
+    end
+  end
+end

data/app/controllers/parapet/polyglot_suite/dashboard_controller.rb

@@ -0,0 +1,10 @@
+module Parapet
+  module PolyglotSuite
+    class DashboardController < Parapet::BaseController
+      def index
+        @active_suite = 'polyglot'
+        render "parapet/dashboards/index"
+      end
+    end
+  end
+end

data/app/controllers/parapet/runner_controller.rb

@@ -0,0 +1,34 @@
+require 'open3'
+
+module Parapet
+  class RunnerController < ApplicationController
+    def detect_frameworks
+      runner = Parapet::TestRunner.new
+      frameworks = runner.detect_frameworks
+      render json: { frameworks: frameworks }
+    end
+
+    def execute
+      runner = Parapet::TestRunner.new(user: current_user)
+      result = runner.execute(
+        command_type: params[:command],
+        path: params[:path]
+      )
+
+      render json: {
+        status: "success",
+        command: result[:command],
+        output: result[:output],
+        summary: result[:summary],
+        exit_code: result[:exit_code]
+      }
+    rescue => e
+      render json: { status: "error", error: e.message }
+    end
+
+    def status
+      # Placeholder for long-running test status checks
+      render json: { status: "idle" }
+    end
+  end
+end

data/app/controllers/parapet/sessions_controller.rb

@@ -0,0 +1,35 @@
+module Parapet
+  class SessionsController < ApplicationController
+    layout "parapet/landing"
+
+    skip_before_action :require_authentication, only: %i[new create]
+    rate_limit to: 10, within: 3.minutes, only: :create, with: -> { redirect_to login_path, alert: "Try again later." }
+
+    def new
+    end
+
+    def create
+      user = User.authenticate_by(params.permit(:email_address, :password))
+
+      if user
+        Current.session&.destroy
+        Current.session = user.sessions.create!
+        cookies.encrypted.permanent[:parapet_session_id] = {
+          value: Current.session.id,
+          httponly: true,
+          same_site: :lax
+        }
+        redirect_to root_path
+      else
+        flash.now[:alert] = "Invalid email address or password."
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      Current.session&.destroy
+      cookies.delete(:parapet_session_id)
+      redirect_to login_path
+    end
+  end
+end

data/app/controllers/parapet/signal_suite/dashboard_controller.rb

@@ -0,0 +1,10 @@
+module Parapet
+  module SignalSuite
+    class DashboardController < Parapet::BaseController
+      def index
+        @active_suite = 'signal'
+        render "parapet/dashboards/index"
+      end
+    end
+  end
+end

data/app/controllers/parapet/test_suite/dashboard_controller.rb

@@ -0,0 +1,10 @@
+module Parapet
+  module TestSuite
+    class DashboardController < Parapet::BaseController
+      def index
+        @active_suite = 'tests'
+        render "parapet/dashboards/index"
+      end
+    end
+  end
+end

data/app/controllers/parapet/widgets_controller.rb

@@ -0,0 +1,33 @@
+module Parapet
+  class WidgetsController < ApplicationController
+    def show
+      @widget_type = params[:type]
+      @audit_stats = Parapet::ExplorerManager.audit_data(@widget_type)
+
+      # Determine which partial to render based on suite type
+      # We look for a suite-specific widget partial first
+      suite_partial = "parapet/shared/widgets/#{@widget_type}"
+
+      if lookup_context.exists?(suite_partial, [], true)
+        render partial: suite_partial
+      else
+        # Fallback to legacy partial map or base widget
+        partial_map = {
+          "search"      => "parapet/widgets/search",
+          "explainer"   => "parapet/widgets/explainer",
+          "snippets"    => "parapet/widgets/snippets",
+          "suggestions" => "parapet/widgets/suggestions",
+          "hotkeys"     => "parapet/widgets/hotkeys"
+        }
+
+        @partial_path = partial_map[@widget_type]
+
+        if @partial_path && lookup_context.exists?(@partial_path, [], true)
+          render partial: @partial_path
+        else
+          render partial: "parapet/shared/widgets/base"
+        end
+      end
+    end
+  end
+end

data/app/helpers/parapet/application_helper.rb

@@ -0,0 +1,23 @@
+module Parapet
+  module ApplicationHelper
+    include IconHelper
+
+    def storage_path(filename = nil)
+      ExplorerManager.storage_path(filename)
+    end
+
+    def explorer_summary(type = 'project')
+      ExplorerManager.summary(type)
+    end
+
+    def qss
+      if Rails.env.development?
+        # Force reload of QSS lib during development
+        qss_path = File.expand_path('../../../../lib/parapet/qss.rb', __FILE__)
+        load qss_path if File.exist?(qss_path)
+        ::QSS.instance_variable_set(:@objects, nil)
+      end
+      ::QSS
+    end
+  end
+end

data/app/helpers/parapet/icon_helper.rb

@@ -0,0 +1,57 @@
+require 'nokogiri'
+
+module Parapet
+  module IconHelper
+    def pp_icon(name, **options)
+      css_class = options.delete(:class)
+
+      # Try resolving custom SVG icon first
+      asset = resolve_icon_asset(name)
+
+      content = if asset
+        render_svg_icon(asset, name, options)
+      else
+        render_lucide_icon(name, options)
+      end
+
+      content_tag(:span, content, class: "qss-icon-wrap qss-w-4 qss-h-4 #{css_class}".strip, **options)
+    end
+
+    private
+
+    def resolve_icon_asset(name)
+      paths = [
+        "parapet/icons/activities/#{name}.svg",
+        "parapet/icons/nav/#{name}.svg",
+        "parapet/icons/#{name}.svg"
+      ]
+
+      paths.each do |path|
+        # Propshaft resolution API
+        found = Rails.application.assets.load_path.find(path)
+        return found if found
+      end
+      nil
+    end
+
+    def render_svg_icon(asset, name, options)
+      raw_svg = File.read(asset.path)
+      doc = Nokogiri::HTML::DocumentFragment.parse(raw_svg)
+      svg = doc.at_css('svg')
+
+      if svg
+        # Ensure structural sizing classes are present
+        svg['class'] = "qss-icon-raw qss-w-full qss-h-full #{svg['class']}".strip
+        svg.remove_attribute('width')
+        svg.remove_attribute('height')
+        svg['aria-hidden'] = 'true'
+      end
+
+      doc.to_html.html_safe
+    end
+
+    def render_lucide_icon(name, options)
+      content_tag(:i, nil, class: "lucide-#{name} qss-icon-lucide qss-w-full qss-h-full", aria: { hidden: true })
+    end
+  end
+end

data/app/jobs/parapet/application_job.rb

@@ -0,0 +1,4 @@
+module Parapet
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/parapet/application_mailer.rb

@@ -0,0 +1,6 @@
+module Parapet
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/parapet/activity.rb

@@ -0,0 +1,14 @@
+module Parapet
+  class Activity < InternalRecord
+    self.table_name = "activities"
+
+    belongs_to :user, class_name: "Parapet::User", optional: true
+    belongs_to :trackable, polymorphic: true, optional: true
+
+    validates :activity_type, presence: true
+    validates :action, presence: true
+    validates :performed_via, inclusion: { in: %w[human ai_agent] }
+
+    scope :recent, -> { order(created_at: :desc) }
+  end
+end

data/app/models/parapet/application_record.rb

@@ -0,0 +1,5 @@
+module Parapet
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/parapet/current.rb

@@ -0,0 +1,6 @@
+module Parapet
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :session
+    delegate :user, to: :session, allow_nil: true
+  end
+end

data/app/models/parapet/draft_recovery.rb

@@ -0,0 +1,9 @@
+module Parapet
+  class DraftRecovery < InternalRecord
+    self.table_name = "draft_recoveries"
+
+    belongs_to :user, class_name: "Parapet::User"
+
+    validates :file_path, presence: true, uniqueness: { scope: :user_id }
+  end
+end

data/app/models/parapet/internal_record.rb

@@ -0,0 +1,34 @@
+require "fileutils"
+
+module Parapet
+  class InternalRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    database_filename = Rails.env.test? ? "parapet-test.sqlite3" : "parapet.sqlite3"
+    database_path = Rails.root.join("storage", database_filename)
+    FileUtils.mkdir_p(database_path.dirname)
+
+    establish_connection(
+      adapter: "sqlite3",
+      database: database_path.to_s,
+      pool: ENV.fetch("RAILS_MAX_THREADS", 5),
+      timeout: 5000,
+      pragmas: { journal_mode: "wal" }
+    )
+
+    def self.migrate!
+      database_tasks = ActiveRecord::Tasks::DatabaseTasks
+      original_migration_class = database_tasks.method(:migration_class)
+      database_tasks.define_singleton_method(:migration_class) { Parapet::InternalRecord }
+
+      migration_context = ActiveRecord::MigrationContext.new(
+        [ Parapet::Engine.root.join("db/parapet_migrate").to_s ],
+        connection_pool.schema_migration,
+        connection_pool.internal_metadata
+      )
+      migration_context.migrate
+    ensure
+      database_tasks.define_singleton_method(:migration_class, original_migration_class) if original_migration_class
+    end
+  end
+end

data/app/models/parapet/run_history.rb

@@ -0,0 +1,22 @@
+module Parapet
+  class RunHistory < ApplicationRecord
+    self.table_name = "run_history"
+
+    belongs_to :user, class_name: "Parapet::User", optional: true
+
+    validates :run_type, presence: true
+    validates :command, presence: true
+    validates :status, presence: true
+    validates :triggered_by_actor_type, presence: true
+    validates :performed_via, inclusion: { in: %w[human ai_agent] }
+    validates :started_at, presence: true
+
+    def passed?
+      status == "passed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+  end
+end

data/app/models/parapet/runtime_setting.rb

@@ -0,0 +1,8 @@
+module Parapet
+  class RuntimeSetting < InternalRecord
+    self.table_name = "runtime_settings"
+
+    validates :setting_key, presence: true, uniqueness: true
+    validates :value, presence: true
+  end
+end

data/app/models/parapet/session.rb

@@ -0,0 +1,7 @@
+module Parapet
+  class Session < InternalRecord
+    self.table_name = "sessions"
+
+    belongs_to :user
+  end
+end

data/app/models/parapet/suite_assignment.rb

@@ -0,0 +1,30 @@
+module Parapet
+  class SuiteAssignment < InternalRecord
+    self.table_name = "suite_assignments"
+
+    SUITES = %w[
+      authentication
+      authorization
+      licensing
+      activity_tracking
+      intentions_suite
+      style_suite
+      test_suite
+      build_suite
+      database_suite
+      signal_suite
+      process_monitor
+      polyglot_suite
+      pm_suite
+    ].freeze
+
+    TIERS = %w[novice intermediate advanced power].freeze
+
+    belongs_to :user, class_name: "Parapet::User"
+
+    validates :suite, inclusion: { in: SUITES }
+    validates :suite, uniqueness: { scope: :user_id }
+    validates :role, presence: true, allow_nil: true, length: { maximum: 64 }
+    validates :tier, inclusion: { in: TIERS }
+  end
+end