parapet-rails 0.1.0

data/app/assets/stylesheets/parapet/qss_application.scss

@@ -0,0 +1,5 @@
+@import "qss_variables"; // Parapet's QSS settings, before core so they win over core's !default values
+@import "qss/qss_core"; // from the qss gem (QSS.stylesheets_path on the Sass load path)
+@import "parapet_qss";
+@import "qss_workspace";
+/* Cache Buster: <%= Time.now.to_i %> */

data/app/assets/stylesheets/parapet/qss_workspace.scss

@@ -0,0 +1,209 @@
+:root {
+    --header-h: 60px;
+    --novice: #10B981;
+    --intermediate: #F59E0B;
+    --advanced: #EF4444;
+    --power: #8B5CF6;
+}
+
+/* Structural Layout Integrity */
+#pp-main-root,
+#pp-header,
+#pp-header-inner,
+#pp-header-branding,
+#pp-header-tagline,
+#pp-header-ribbon,
+#pp-workspace-layers,
+#pp-workspace-content,
+#pp-inspector-bar,
+#pp-code-source,
+#pp-code-compiled,
+#pp-footer,
+#pp-preview-iframe {
+    contain: layout;
+}
+
+/* Header & Ribbon Structural Layout (Compiled) */
+.qss-header-inner {
+    display: flex;
+    width: 100%;
+    height: 100%;
+    flex-direction: row;
+    align-items: center;
+    padding-left: 0.75rem;
+    padding-right: 0.75rem;
+    justify-content: space-between;
+}
+
+.qss-header-branding {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 1.5rem;
+    width: var(--branding-w, 200px);
+    height: 100%;
+}
+
+.qss-header-tagline {
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+    width: var(--tagline-w, 150px);
+    height: 100%;
+}
+
+.qss-header-ribbon {
+    flex: 1 1 0%;
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: center;
+    gap: 2rem;
+    height: 100%;
+}
+
+.qss-ribbon-group {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.125rem;
+}
+
+.qss-ribbon-activities {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+.qss-proficiency-filter-wrap {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.125rem;
+    padding-left: 0.5rem;
+    padding-right: 0.5rem;
+    border-right: 1px solid rgba(30, 41, 59, 0.5);
+    height: 100%;
+}
+
+.qss-proficiency-filter-items {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.375rem;
+}
+
+#pp-header-branding {
+    width: var(--branding-w, 200px);
+    height: 100%;
+}
+
+#pp-header-tagline {
+    width: var(--tagline-w, 150px);
+    height: 100%;
+}
+
+#pp-header-ribbon {
+    width: auto;
+    height: 100%;
+}
+
+/* Scrollbar Standard */
+::-webkit-scrollbar { width: 7px; height: 7px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { 
+    background: #334155; 
+    border-radius: 100px; 
+    border: 1.5px solid transparent;
+    background-clip: content-box;
+}
+::-webkit-scrollbar-thumb:hover { background: #475569; background-clip: content-box; }
+
+/* Icon Standardization */
+.qss-icon-wrap {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    line-height: 1;
+}
+
+.qss-icon-raw,
+.qss-icon-lucide {
+    width: 100%;
+    height: 100%;
+    display: block;
+}
+
+[class^="lucide-"], [class*=" lucide-"],
+[class^="qss-icon-"], [class*=" qss-icon-"],
+[class^="icon-"]:not(.icon-path), [class*=" icon-"]:not(.icon-path) {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 14px;
+    width: 14px;
+    height: 14px;
+}
+
+/* Reactive QSS Properties */
+.qss-mini-explorer-dropdown, 
+.qss-new-menu-dropdown, 
+.qss-link-menu-dropdown {
+    top: var(--dropdown-top, auto);
+    left: var(--dropdown-left, auto);
+}
+
+.qss-snippet-drawer {
+    width: var(--drawer-w, 0px);
+}
+
+.qss-fix-footer {
+    height: var(--footer-h, 0px);
+}
+
+/* File Editor Structural Identities */
+#pp-file-editor-shell {
+    contain: layout;
+}
+
+#pp-editor-viewport {
+    display: flex;
+    gap: 1px;
+    padding: 1px;
+    background-color: #0b0d11;
+    contain: layout;
+}
+
+[id^="pp-editor-pane-"] {
+    contain: layout;
+}
+
+.no-scrollbar {
+    scrollbar-width: none;
+    -ms-overflow-style: none;
+    &::-webkit-scrollbar {
+        display: none;
+    }
+}
+
+
+.qss-pointer-events-none {
+    pointer-events: none;
+}
+
+.qss-pointer-events-auto {
+    pointer-events: auto;
+}
+
+/* Explicit hidden-state rule: the runtime engine is unreliable for toggling
+   display on this pre-migration element; this ID+class rule wins on
+   specificity without needing !important. */
+#pp-preview-popup.qss {
+    display: flex;
+    flex-direction: column;
+}
+
+#pp-preview-popup.qss.hidden {
+    display: none;
+}

data/app/assets/stylesheets/parapet/sample.qss

@@ -0,0 +1,22 @@
+/**
+ * Sample QSS File
+ * Verifies the local transpiler loop.
+ */
+
+#qss-test-object {
+  x: center;
+  y: 100;
+  w: 200;
+  h: 200;
+  bg: indigo-500;
+  depth: ui;
+  border-b: 2;
+}
+
+.qss-test-label {
+  x: 10;
+  y: 10;
+  text-size: 14;
+  text-color: slate-300;
+  font: bold;
+}

data/app/controllers/parapet/application_controller.rb

@@ -0,0 +1,54 @@
+require "ipaddr"
+
+module Parapet
+  class ApplicationController < ActionController::Base
+    before_action :guard_request
+    before_action :set_current_session
+    before_action :require_authentication
+
+    helper Turbo::FramesHelper
+    helper Turbo::StreamsHelper
+    helper_method :current_user
+
+    def index
+      render "parapet/application"
+    end
+
+    private
+
+    def set_current_session
+      Current.session = Session.find_by(id: cookies.encrypted[:parapet_session_id])
+    end
+
+    def require_authentication
+      redirect_to login_path unless Current.user
+    end
+
+    def current_user
+      Current.user
+    end
+
+    def guard_request
+      environment = Rails.env.to_s
+      return head(:not_found) unless %w[development test].include?(environment)
+      return head(:not_found) unless loopback_request?
+      head(:not_found) unless expected_subdomain?
+    end
+
+    def loopback_request?
+      IPAddr.new(request.remote_ip).loopback?
+    rescue IPAddr::InvalidAddressError, ActionDispatch::RemoteIp::IpSpoofAttackError
+      false
+    end
+
+    # Defense in depth: the engine's own mount already constrains routing to this
+    # subdomain, so any request reaching this controller through normal routing is
+    # guaranteed to already satisfy this. This check exists for the cases that bypass
+    # normal routing -- a second, unconstrained mount point added by mistake, or direct
+    # invocation outside the router -- not for DNS-rebinding defense (the mount
+    # constraint and Host authorization handle that).
+    def expected_subdomain?
+      request.subdomain == Parapet.mount_subdomain
+    end
+  end
+end

data/app/controllers/parapet/base_controller.rb

@@ -0,0 +1,18 @@
+module Parapet
+  class BaseController < ApplicationController
+    include ApplicationHelper
+    helper ApplicationHelper
+
+    before_action :set_suite_context
+
+    protected
+
+    def set_suite_context
+      @explorer_type = 'project'
+      @root_path = Parapet::Engine.root.to_s
+      @scanner = Parapet::DirectoryScanner.new(@root_path)
+      physical_tree = @scanner.scan
+      @tree_data = Parapet::ExplorerManager.virtualize(physical_tree, @explorer_type)
+    end
+  end
+end

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

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

data/app/controllers/parapet/css_suite/compiler_controller.rb

@@ -0,0 +1,95 @@
+module Parapet
+  module CssSuite
+    class CompilerController < ApplicationController
+      def grammar
+        registry_path = Parapet::Engine.root.join("app/assets/config/parapet/grammar-registry.json")
+        if File.exist?(registry_path)
+          render json: JSON.parse(File.read(registry_path))
+        else
+          render json: { error: "Grammar registry not found" }, status: :not_found
+        end
+      end
+
+      # Bypasses Propshaft/Sprockets to serve the absolute latest generated core
+      def live
+        scss_path = File.join(QSS.stylesheets_path, "qss", "qss_core.scss")
+
+        if File.exist?(scss_path)
+          begin
+            result = Sass.compile_string(
+              "@import \"parapet/qss_variables\";\n@import \"qss/qss_core\";\n", # Parapet's settings, then core (as in qss_application.scss)
+              load_paths: [ Parapet::Engine.root.join("app/assets/stylesheets").to_s, QSS.stylesheets_path ],
+              syntax: :scss,
+              style: :expanded
+            )
+            render plain: result.css, content_type: 'text/css'
+          rescue => e
+            logger.error "SCSS Compilation Error: #{e.message}\n#{e.backtrace.join("\n")}"
+            render plain: "/* SCSS Compilation Error: #{e.message} */", content_type: 'text/css', status: :internal_server_error
+          end
+        else
+          render plain: "/* qss_core.scss not found at #{scss_path} */", content_type: 'text/css', status: :not_found
+        end
+      end
+
+      def compile
+        scss_content = params[:scss]
+
+        if scss_content.blank?
+          render json: { css: "", error: nil }
+          return
+        end
+
+        begin
+          # Compile using sass-embedded
+          # We include the engine's stylesheet path for @imports
+          load_paths = [ Parapet::Engine.root.join("app/assets/stylesheets").to_s ]
+
+          result = Sass.compile_string(
+            scss_content,
+            load_paths: load_paths,
+            syntax: :scss,
+            style: :expanded
+          )
+
+          render json: { css: result.css, error: nil }
+        rescue Sass::CompileError => e
+          render json: {
+            css: nil,
+            error: e.message,
+            line: e.span&.start&.line,
+            column: e.span&.start&.column
+          }, status: :unprocessable_entity
+        rescue => e
+          render json: { css: nil, error: "System Error: #{e.message}" }, status: :internal_server_error
+        end
+      end
+
+      def flush
+        path = params[:path]
+        content = params[:content]
+
+        if path.blank? || content.nil?
+          render json: { error: "Path and content are required" }, status: :bad_request
+          return
+        end
+
+        full_path = File.expand_path(Rails.root.join(path).to_s)
+        root_path = File.expand_path(Rails.root.to_s)
+        root_prefix = root_path.end_with?(File::SEPARATOR) ? root_path : "#{root_path}#{File::SEPARATOR}"
+
+        unless full_path == root_path || full_path.start_with?(root_prefix)
+          render json: { error: "Access Denied" }, status: :forbidden
+          return
+        end
+
+        begin
+          File.write(full_path, content)
+          render json: { success: true, path: path }
+        rescue => e
+          render json: { error: "Failed to write file: #{e.message}" }, status: :internal_server_error
+        end
+      end
+    end
+  end
+end

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

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

data/app/controllers/parapet/css_suite/preview_controller.rb

@@ -0,0 +1,46 @@
+module Parapet
+  module CssSuite
+    class PreviewController < ApplicationController
+      layout false
+
+      def show
+        path = params[:path].to_s
+        Rails.logger.info "Styles Workbench: Preview Request for #{path}"
+
+        if path.blank? || !path.end_with?('.erb')
+          Rails.logger.warn "Styles Workbench: Invalid preview path: #{path}"
+          render plain: "Select an ERB view file to preview.", status: :bad_request
+          return
+        end
+
+        # Security & Path Resolution
+        root_path = File.expand_path(Parapet::Engine.root.to_s)
+        full_path = File.expand_path(File.join(root_path, path.sub(/^\//, '')))
+
+        unless full_path.start_with?(root_path) && File.exist?(full_path)
+          render plain: "File not found or access denied.", status: :not_found
+          return
+        end
+
+        begin
+          # We attempt to render the file as a partial.
+          prepend_view_path Parapet::Engine.root.join("app/views")
+
+          # app/views/parapet/shared/_header.html.erb -> parapet/shared/header
+          clean_path = path.sub(%r{^.*app/views/}, '').sub(/\.html\.erb$/, '')
+
+          # Remove leading underscore from the final segment (the filename)
+          parts = clean_path.split('/')
+          parts[-1] = parts[-1].sub(/^_/, '')
+          partial_path = parts.join('/')
+
+          render partial: partial_path
+        rescue => e
+          render html: "<div class='qss-p[20] qss-bg-red-500/10 qss-border qss-border-red-500/20 qss-text-red-400 qss-text-size[11]'>
+                          <strong>Preview Error:</strong><br/>#{e.message}
+                        </div>".html_safe
+        end
+      end
+    end
+  end
+end

data/app/controllers/parapet/dashboard_controller.rb

@@ -0,0 +1,8 @@
+module Parapet
+  class DashboardController < Parapet::BaseController
+    def index
+      @active_suite = params[:suite] || 'project'
+      render "parapet/dashboards/index"
+    end
+  end
+end

data/app/controllers/parapet/drafts_controller.rb

@@ -0,0 +1,30 @@
+module Parapet
+  class DraftsController < ApplicationController
+    def show
+      draft = DraftRecoveryStore.find(user: current_user, path: file_path)
+      return head :no_content unless draft
+
+      render json: { content: draft.content }
+    end
+
+    def update
+      DraftRecoveryStore.save!(
+        user: current_user,
+        path: file_path,
+        content: params[:content].to_s
+      )
+      head :no_content
+    end
+
+    def destroy
+      DraftRecoveryStore.clear!(user: current_user, path: file_path)
+      head :no_content
+    end
+
+    private
+
+    def file_path
+      params[:path].to_s.sub(/^\//, "")
+    end
+  end
+end

data/app/controllers/parapet/explorers_controller.rb

@@ -0,0 +1,53 @@
+module Parapet
+  class ExplorersController < ApplicationController
+    include ApplicationHelper
+
+    def show
+      @explorer_type = params[:type] || 'project'
+      @perspective = params[:perspective] || 'project'
+
+      # Always scan from the engine root to allow cross-directory virtualization (like Registry)
+      @root_path = Parapet::Engine.root.to_s
+
+      # Initialize scanner and generate tree
+      @scanner = Parapet::DirectoryScanner.new(@root_path)
+      physical_tree = @scanner.scan
+
+      # Transform the physical tree into virtual perspectives
+      @tree_data = Parapet::ExplorerManager.virtualize(physical_tree, @explorer_type, perspective: @perspective)
+
+      # Determine which partial to render
+      mapped_type = case @explorer_type
+      when 'styles' then 'css'
+      when 'ideas' then 'intentions'
+      else @explorer_type
+      end
+
+      explorer_partial = "parapet/shared/explorers/#{mapped_type}"
+      unless lookup_context.exists?(explorer_partial, [], true)
+        explorer_partial = "parapet/shared/explorers/base"
+      end
+
+      respond_to do |format|
+        format.turbo_stream do
+          if turbo_frame_request?
+            render partial: explorer_partial, locals: { type: @explorer_type, tree_data: @tree_data }
+          else
+            render turbo_stream: [
+              turbo_stream.replace("qss-perspective-filters", partial: "parapet/activities/perspective_filters", locals: { explorer_type: @explorer_type }),
+              turbo_stream.replace("qss-explorer-content", partial: explorer_partial, locals: { type: @explorer_type, tree_data: @tree_data }),
+              turbo_stream.replace("qss-progress-area", partial: "parapet/activities/progress_area", locals: { summary: Parapet::ExplorerManager.summary(@explorer_type), root_path: @root_path })
+            ]
+          end
+        end
+        format.html do
+          if turbo_frame_request?
+            render partial: explorer_partial, locals: { type: @explorer_type, tree_data: @tree_data }
+          else
+            render partial: "parapet/activities/explorer_tree", locals: { tree_data: @tree_data }
+          end
+        end
+      end
+    end
+  end
+end