parapet-rails 0.1.0

data/app/models/parapet/user.rb

@@ -0,0 +1,12 @@
+module Parapet
+  class User < InternalRecord
+    self.table_name = "users"
+
+    has_secure_password
+    has_many :sessions, dependent: :destroy
+
+    normalizes :email_address, with: ->(email_address) { email_address.strip.downcase }
+
+    validates :email_address, presence: true, uniqueness: true
+  end
+end

data/app/services/parapet/activity_phrase_renderer.rb

@@ -0,0 +1,35 @@
+module Parapet
+  class ActivityPhraseRenderer
+    def initialize(view_context:)
+      @view_context = view_context
+    end
+
+    def render(activity:, viewer:)
+      activity_type = activity.activity_type.to_s
+      action = activity.action.to_s
+      partial = [
+        "parapet/activities/#{activity_type}/#{action}",
+        "parapet/activities/#{activity_type}",
+        "parapet/activities/generic"
+      ].find { |candidate| @view_context.lookup_context.exists?(candidate, [], true) }
+
+      @view_context.render(
+        partial: partial,
+        locals: {
+          activity: activity,
+          actor_name: actor_name(activity, viewer),
+          viewer: viewer
+        }
+      )
+    end
+
+    private
+
+    def actor_name(activity, viewer)
+      return "Parapet" unless activity.user
+      return "You" if viewer && activity.user_id == viewer.id
+
+      activity.user.email_address
+    end
+  end
+end

data/app/services/parapet/activity_writer.rb

@@ -0,0 +1,26 @@
+module Parapet
+  class ActivityWriter
+    def self.run!(run_history:, user:, action:, performed_via:)
+      return unless user
+
+      Activity.create!(
+        user: user,
+        activity_type: "run_history",
+        action: action,
+        performed_via: performed_via,
+        trackable: run_history,
+        details: {}
+      )
+    end
+
+    def self.file_saved!(user:, path:, performed_via: "human")
+      Activity.create!(
+        user: user,
+        activity_type: "file_editor",
+        action: "file_saved",
+        performed_via: performed_via,
+        details: { "file_path" => path }
+      )
+    end
+  end
+end

data/app/services/parapet/authorization.rb

@@ -0,0 +1,198 @@
+require "json"
+
+module Parapet
+  module Authorization
+    class Error < StandardError
+    end
+
+    class NotPmCapableError < Error
+    end
+
+    class DelegateLimitExceededError < Error
+    end
+
+    class LastDelegateCannotBeRevokedError < Error
+    end
+
+    class TierCeilingExceededError < Error
+    end
+
+    class BootstrapAlreadyCompletedError < Error
+    end
+
+    class InvalidConfigurationError < Error
+    end
+
+    DELEGATE_SETTING_KEY = "delegate_ids"
+    MAX_DELEGATES = 2
+
+    TIER_RANKS = {
+      "novice" => 0,
+      "intermediate" => 1,
+      "advanced" => 2,
+      "power" => 3
+    }.freeze
+
+    class << self
+      def authorized?(user, suite, min_tier: :novice)
+        return false unless valid_identity?(user)
+
+        suite_name = suite.to_s
+        minimum_rank = TIER_RANKS[min_tier.to_s]
+        return false unless SuiteAssignment::SUITES.include?(suite_name) && minimum_rank
+
+        effective_tier = tier_for(user, suite_name)
+        effective_tier && TIER_RANKS.fetch(effective_tier) >= minimum_rank
+      end
+
+      def tier_for(user, suite)
+        return unless valid_identity?(user)
+
+        suite_name = suite.to_s
+        return unless SuiteAssignment::SUITES.include?(suite_name)
+
+        assignment = SuiteAssignment.find_by(user_id: user.id, suite: suite_name)
+        tier = assignment&.tier || ("novice" if suite_name == "intentions_suite")
+        assigned_rank = TIER_RANKS[tier]
+        ceiling_rank = TIER_RANKS[license_ceiling.to_s]
+        return unless assigned_rank && ceiling_rank
+
+        TIER_RANKS.key([ assigned_rank, ceiling_rank ].min)
+      end
+
+      def role_for(user, suite)
+        return unless valid_identity?(user)
+
+        suite_name = suite.to_s
+        return unless SuiteAssignment::SUITES.include?(suite_name)
+
+        SuiteAssignment.find_by(user_id: user.id, suite: suite_name)&.role
+      end
+
+      def pm_capable?(user)
+        valid_identity?(user) && delegate_ids.include?(user.id)
+      end
+
+      def bootstrap_owner!(owner:)
+        ensure_identity!(owner)
+
+        RuntimeSetting.transaction do
+          setting = RuntimeSetting.lock.find_by(setting_key: DELEGATE_SETTING_KEY)
+
+          if setting
+            ids = parse_delegate_ids(setting.value)
+            raise BootstrapAlreadyCompletedError unless ids.include?(owner.id)
+          else
+            RuntimeSetting.create!(
+              setting_key: DELEGATE_SETTING_KEY,
+              value: JSON.generate([ owner.id ])
+            )
+          end
+        end
+
+        owner
+      end
+
+      def grant_pm!(actor:, user:)
+        require_pm!(actor)
+        ensure_identity!(user)
+
+        update_delegate_ids do |ids|
+          next ids if ids.include?(user.id)
+          raise DelegateLimitExceededError if ids.length >= MAX_DELEGATES
+
+          ids + [ user.id ]
+        end
+
+        user
+      end
+
+      def revoke_pm!(actor:, user:)
+        require_pm!(actor)
+        ensure_identity!(user)
+
+        update_delegate_ids do |ids|
+          raise LastDelegateCannotBeRevokedError if ids == [ user.id ]
+
+          ids.reject { |id| id == user.id }
+        end
+        user
+      end
+
+      def assign!(actor:, user:, suite:, role: nil, tier: nil)
+        require_pm!(actor)
+        ensure_identity!(user)
+
+        suite_name = suite.to_s
+        raise ArgumentError, "Unknown suite" unless SuiteAssignment::SUITES.include?(suite_name)
+        raise ArgumentError, "Provide a role, a tier, or both" if role.nil? && tier.nil?
+
+        tier_name = tier&.to_s
+        if tier_name
+          tier_rank = TIER_RANKS[tier_name]
+          ceiling_rank = TIER_RANKS[license_ceiling.to_s]
+          raise ArgumentError, "Unknown tier" unless tier_rank
+          raise TierCeilingExceededError if tier_rank > ceiling_rank
+        end
+
+        assignment = SuiteAssignment.find_or_initialize_by(user: user, suite: suite_name)
+        assignment.role = role.to_s unless role.nil?
+        assignment.tier = tier_name if tier_name
+        assignment.save!
+        assignment
+      end
+
+      def license_ceiling
+        :power
+      end
+
+      private
+
+      def delegate_ids
+        setting = RuntimeSetting.find_by(setting_key: DELEGATE_SETTING_KEY)
+        setting ? parse_delegate_ids(setting.value) : []
+      end
+
+      def parse_delegate_ids(value)
+        ids = JSON.parse(value)
+        unless ids.is_a?(Array) && ids.length <= MAX_DELEGATES && ids.uniq == ids && ids.all? { |id| id.is_a?(Integer) && id.positive? }
+          raise InvalidConfigurationError
+        end
+
+        ids
+      rescue JSON::ParserError, TypeError
+        raise InvalidConfigurationError
+      end
+
+      def update_delegate_ids
+        RuntimeSetting.transaction do
+          setting = RuntimeSetting.lock.find_by(setting_key: DELEGATE_SETTING_KEY)
+          ids = setting ? parse_delegate_ids(setting.value) : []
+          updated_ids = yield(ids)
+          raise DelegateLimitExceededError if updated_ids.length > MAX_DELEGATES
+
+          value = JSON.generate(updated_ids)
+          if setting
+            setting.update!(value: value)
+          else
+            RuntimeSetting.create!(setting_key: DELEGATE_SETTING_KEY, value: value)
+          end
+        end
+      end
+
+      def require_pm!(user)
+        raise NotPmCapableError unless pm_capable?(user)
+      end
+
+      def ensure_identity!(user)
+        unless valid_identity?(user)
+          raise ArgumentError, "User must be a persisted account with credentials"
+        end
+      end
+
+      def valid_identity?(user)
+        user.is_a?(User) && user.persisted? && user.password_digest.present?
+      end
+    end
+  end
+end

data/app/services/parapet/consistency_auditor.rb

@@ -0,0 +1,58 @@
+require 'nokogiri'
+require 'json'
+require 'digest'
+
+module Parapet
+  class ConsistencyAuditor
+    CONSISTENT_IDS = [
+      'pp-header',
+      'pp-footer',
+      'pp-global-nav',
+      'pp-explorer-bar',
+      'pp-inspector-bar'
+    ].freeze
+
+    def self.audit_project(root_path)
+      fingerprints = {} # id => { hash => [files] }
+
+      # Normalize path for Windows/Unix consistency
+      base_dir = File.expand_path(root_path)
+      pattern = File.join(base_dir, 'app', 'views', '**', '*.html.erb').gsub('\\', '/')
+
+      Dir.glob(pattern).each do |file|
+        next if file.include?('/shared/') # Skip partials as they are the source of truth
+
+        content = File.read(file) rescue next
+        doc = Nokogiri::HTML.fragment(content.gsub(/<%.*?%>/m, '<!--ERB-->'))
+
+        CONSISTENT_IDS.each do |id|
+          node = doc.at_css("##{id}")
+          next unless node
+
+          # Normalize node for comparison (remove whitespace/comments)
+          normalized = node.to_s.gsub(/\s+/, ' ').strip
+          hash = Digest::SHA256.hexdigest(normalized)
+
+          fingerprints[id] ||= {}
+          fingerprints[id][hash] ||= []
+          fingerprints[id][hash] << file.sub(base_dir, '')
+        end
+      end
+
+      issues = []
+      fingerprints.each do |id, variants|
+        if variants.size > 1
+          issues << {
+            type: 'consistency',
+            id: id,
+            message: "Structural Drift Detected: Element ##{id} has #{variants.size} different implementations across your views.",
+            variants: variants,
+            severity: 'red'
+          }
+        end
+      end
+
+      { status: issues.empty? ? 'green' : 'red', issues: issues }
+    end
+  end
+end

data/app/services/parapet/directory_scanner.rb

@@ -0,0 +1,159 @@
+module Parapet
+  class DirectoryScanner
+    def initialize(root_path)
+      @root_path = root_path
+    end
+
+    def scan
+      return nil unless File.directory?(@root_path)
+
+      {
+        name: File.basename(@root_path),
+        type: 'directory',
+        path: '/',
+        icon: 'icon-folder qss-icon-folder',
+        children: scan_directory(@root_path, '')
+      }
+    end
+
+    private
+
+    def scan_directory(current_path, relative_path)
+      items = []
+
+      # Directories to ignore (case-insensitive)
+      ignore_list = [ '.', '..', '.git', '.bundle', 'node_modules', 'tmp', 'log' ]
+
+      Dir.foreach(current_path) do |item|
+        next if ignore_list.any? { |ignored| item.downcase == ignored.downcase }
+        next if item == '.keep'
+        next if item.start_with?('.') && item != '.zencoder' # Keep our own folder for dogfooding
+
+        full_path = File.join(current_path, item)
+        item_relative_path = if relative_path.empty?
+          item
+        else
+          File.join(relative_path, item)
+        end.gsub('\\', '/')
+
+        if File.directory?(full_path)
+          children = scan_directory(full_path, item_relative_path)
+          health = calculate_health(children)
+
+          items << {
+            name: item,
+            type: 'directory',
+            path: item_relative_path,
+            icon: 'icon-folder',
+            children: children,
+            health: health
+          }
+        else
+          ext = File.extname(item).delete('.')
+          status = determine_status(full_path, item, ext)
+
+          # Detect Sidecar (.qss) for View files
+          sidecar = nil
+          if [ 'html', 'erb' ].include?(ext)
+            qss_item = item.sub(/\.(html\.erb|erb)$/, '.qss')
+            if File.exist?(File.join(current_path, qss_item))
+              sidecar = File.join(relative_path, qss_item).gsub('\\', '/')
+            end
+          end
+
+          items << {
+            name: item,
+            type: 'file',
+            path: item_relative_path,
+            ext: ext,
+            icon: icon_for_file(item, ext),
+            iconColor: color_for_file(item, ext),
+            status: status,
+            children: [],
+            sidecar: sidecar
+          }
+        end
+      end
+
+      items.sort_by { |i| [ i[:type] == 'directory' ? 0 : 1, i[:name] ] }
+    end
+
+    def determine_status(full_path, name, ext)
+      # 1. Use QSS Auditor for view/style files
+      if [ 'html', 'erb', 'qss', 'css', 'scss' ].include?(ext)
+        return QSS::QssAuditor.audit_file(full_path)[:status]
+      end
+
+      # 2. Use stable "random" status for other files to simulate active project state
+      return nil unless is_test_file?(name) || ext == 'rb'
+
+      hash = name.hash % 100
+      if hash < 60
+        'green'
+      elsif hash < 85
+        'red'
+      elsif hash < 95
+        'orange'
+      else
+        'grey'
+      end
+    end
+
+    def calculate_health(children)
+      return nil if children.empty?
+
+      stats = { 'red' => 0, 'green' => 0, 'orange' => 0, 'grey' => 0 }
+      count = 0
+
+      children.each do |child|
+        if child[:type] == 'file'
+          if child[:status]
+            stats[child[:status]] += 1
+            count += 1
+          end
+        elsif child[:type] == 'directory' && child[:health]
+          # Factor in directory health
+          child[:health].each do |status, percent|
+            stats[status] += (percent / 100.0)
+          end
+          count += 1
+        end
+      end
+
+      return nil if count == 0
+
+      # Convert to percentages
+      stats.transform_values { |v| (v / count.to_f * 100).round }
+    end
+
+    def is_test_file?(name)
+      if Parapet.test_framework == :rspec
+        name.end_with?('_spec.rb')
+      else
+        name.end_with?('_test.rb')
+      end
+    end
+
+    def icon_for_file(name, ext)
+      return 'icon-gem' if is_test_file?(name)
+
+      case ext
+      when 'rb' then 'icon-gem'
+      when 'feature' then 'icon-list-checks'
+      when 'json' then 'icon-database'
+      else 'icon-file'
+      end
+    end
+
+    def color_for_file(name, ext)
+      return 'qss-text-amber-500' if is_test_file?(name)
+
+      case ext
+      when 'rb' then 'qss-text-red-400'
+      when 'feature' then 'qss-text-emerald-400'
+      when 'json' then 'qss-text-indigo-300'
+      else 'qss-text-slate-400'
+      end
+    end
+  end
+end

data/app/services/parapet/draft_recovery_store.rb

@@ -0,0 +1,18 @@
+module Parapet
+  class DraftRecoveryStore
+    def self.find(user:, path:)
+      DraftRecovery.find_by(user_id: user.id, file_path: path)
+    end
+
+    def self.save!(user:, path:, content:)
+      draft = DraftRecovery.find_or_initialize_by(user_id: user.id, file_path: path)
+      draft.content = content
+      draft.save!
+      draft
+    end
+
+    def self.clear!(user:, path:)
+      DraftRecovery.where(user_id: user.id, file_path: path).delete_all
+    end
+  end
+end