RubyGems - archsight - Versions diffs - 0.1.5 → 0.2.0 - Mend

archsight 0.1.5 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (168) hide show

data/lib/archsight/web/api/routes.rb CHANGED Viewed

@@ -42,6 +42,15 @@ module Archsight::Web::API::Routes
     json_response(build_list_response(kind, pagination, resources))
   end
+  # GET /api/v1/kinds/:kind/filters - Get filterable annotations with values
+  get "/api/v1/kinds/:kind/filters" do
+    kind = params[:kind]
+    klass = Archsight::Resources[kind]
+    json_error("Kind '#{kind}' not found", status: 404, error_type: "NotFound") unless klass
+    json_response(build_filters_response(kind))
+  end
   # GET /api/v1/kinds/:kind/instances/:name - Get instance details with relations
   get "/api/v1/kinds/:kind/instances/:name" do
     kind = params[:kind]
@@ -79,6 +88,20 @@ module Archsight::Web::API::Routes
     end
   end
+  # POST /api/v1/kinds/Analysis/instances/:name/execute - Execute an analysis
+  post "/api/v1/kinds/Analysis/instances/:name/execute" do
+    require "archsight/analysis"
+    name = params[:name]
+    analysis = db.instance_by_kind("Analysis", name)
+    json_error("Analysis '#{name}' not found", status: 404, error_type: "NotFound") unless analysis
+    executor = Archsight::Analysis::Executor.new(db)
+    result = executor.execute(analysis)
+    json_response(build_analysis_result(result))
+  end
   # GET /api/v1/openapi.yaml - OpenAPI specification
   get "/api/v1/openapi.yaml" do
     content_type "text/yaml"

data/lib/archsight/web/application.rb CHANGED Viewed

@@ -2,7 +2,6 @@
 require "sinatra/base"
 require "kramdown"
-require "haml"
 require "erb"
 require "fast_mcp"
@@ -55,9 +54,7 @@ class Archsight::Web::Application < Sinatra::Base
   end
   configure do
-    set :views, File.join(__dir__, "views")
     set :public_folder, File.join(__dir__, "public")
-    set :haml, format: :html5
     set :server, :puma
     set :reload_enabled, true
     set :inline_edit_enabled, false
@@ -83,7 +80,7 @@ class Archsight::Web::Application < Sinatra::Base
         localhost_only: false
   end
-  helpers Archsight::GraphvisHelper, Archsight::GraphvisRenderer, Archsight::Helpers
+  helpers Archsight::GraphvisRenderer, Archsight::Helpers
   # Register API modules
   register Archsight::Web::API::Routes
@@ -156,168 +153,83 @@ class Archsight::Web::Application < Sinatra::Base
     def render_analysis_section(section)
       Archsight::Helpers.render_analysis_section(section, markdown_renderer: method(:markdown))
     end
+    # Serve the Vue SPA shell (built by Vite)
+    def serve_vue
+      vue_path = File.join(settings.public_folder, "vue.html")
+      content_type :html
+      if File.exist?(vue_path)
+        File.read(vue_path)
+      else
+        "<!DOCTYPE html><html><body><p>Vue frontend not built. Run: cd frontend &amp;&amp; npm run build</p></body></html>"
+      end
+    end
   end
   get "/" do
-    haml :index
+    serve_vue
   end
   get "/reload" do
     halt 404, "Reload is disabled" unless settings.reload_enabled
     Archsight::Web::Application.reload!
-    if params["redirect"]&.start_with?("/")
+    if request.env["HTTP_ACCEPT"]&.include?("application/json") || request.xhr?
+      content_type :json
+      JSON.generate({ ok: true })
+    elsif params["redirect"]&.start_with?("/")
       redirect params["redirect"]
     else
       redirect "/"
     end
   rescue Archsight::ResourceError => e
-    @error = e
-    haml :index
-  end
-  get "/doc/resources/:filename" do
-    filename = params["filename"].gsub(/[^a-zA-Z0-9_-]/, "") # sanitize
-    # Convert snake_case to PascalCase for resource kind
-    kind_name = filename.split("_").map(&:capitalize).join
-    begin
-      content = Archsight::Documentation.generate(kind_name)
-      @doc_content = markdown(content)
-    rescue StandardError
-      halt 404, "Documentation not found"
-    end
-    if request.env["HTTP_HX_REQUEST"]
-      "<article>#{@doc_content}</article>"
+    if request.env["HTTP_ACCEPT"]&.include?("application/json") || request.xhr?
+      content_type :json
+      status 422
+      JSON.generate({
+                      error: e.message,
+                      path: relative_error_path(e.ref.path),
+                      line_no: e.ref.line_no,
+                      context: error_context_lines(e.ref.path, e.ref.line_no)
+                    })
     else
-      haml :index
+      content_type :html
+      path = ERB::Util.html_escape(relative_error_path(e.ref.path))
+      msg = ERB::Util.html_escape(e.message)
+      "<!DOCTYPE html><html><body><h3>Error: #{msg}</h3><p>#{path} line #{e.ref.line_no}</p><a href='/'>Back</a></body></html>"
     end
   end
-  get "/doc/:filename" do
-    filename = params["filename"].gsub(/[^a-zA-Z0-9_-]/, "") # sanitize
-    # Check for ERB template first, then plain markdown
-    erb_path = File.join(settings.views, "..", "doc", "#{filename}.md.erb")
-    md_path = File.join(settings.views, "..", "doc", "#{filename}.md")
-    content = if File.exist?(erb_path)
-                template = ERB.new(File.read(erb_path))
-                template.result(binding)
-              elsif File.exist?(md_path)
-                File.read(md_path)
-              else
-                halt 404, "Documentation not found"
-              end
-    @doc_content = markdown(content)
-    if request.env["HTTP_HX_REQUEST"]
-      "<article>#{@doc_content}</article>"
-    else
-      haml :index
-    end
+  get "/doc/resources/:filename" do
+    serve_vue
   end
-  # Shared search logic for both GET and POST
-  def perform_search
-    start_time = Time.now
-    if (@q = params["q"])
-      @instances = db.query(@q)
-    elsif (@tag = params["tag"]) && (@value = params["value"])
-      @method = params["method"] || "=="
-      # Build query string - quote value for string operators, leave unquoted for numeric
-      quoted_value = if %w[> < >= <=].include?(@method)
-                       @value # Numeric comparison, no quotes
-                     else
-                       "\"#{@value.gsub('"', '\\"')}\"" # String comparison, quote it
-                     end
-      @q = "#{@tag} #{@method} #{quoted_value}"
-      @instances = db.query(@q)
-    else
-      @instances = []
-    end
-    if (@kind = params["kind"])
-      @instances = @instances.select { |i| i.kind == @kind } if @kind
-    end
-    @search_time_ms = ((Time.now - start_time) * 1000).round(2)
-  rescue Archsight::Query::QueryError => e
-    @query_error = e
-    @search_time_ms = ((Time.now - start_time) * 1000).round(2)
-    @q = params["q"] || "#{params["tag"]} #{params["method"] || "=="} \"#{params["value"]}\""
+  get "/doc/:filename" do
+    serve_vue
   end
-  # GET /search - for direct URL access, bookmarks, and browser history
+  # GET /search - for direct URL access, Vue SPA handles rendering
   get "/search" do
-    perform_search
-    haml :index
-  end
-  # POST /search - for HTMX requests
-  post "/search" do
-    perform_search
-    haml :search
-  end
-  get "/svg" do
-    content_type :svg
-    create_graph_all(db, :draw_svg)
+    serve_vue
   end
   get "/dot" do
     content_type "text/plain"
-    create_graph_all(db, :draw_dot)
+    create_graph_all(db)
   end
   get "/kinds/:kind" do
-    @kind = params["kind"]
-    haml :index
+    serve_vue
   end
   get "/kinds/:kind/instances/:instance" do
-    @kind = params["kind"]
-    @instance = params["instance"]
-    haml :index
-  end
-  get "/kinds/:kind/instances/:instance/svg" do
-    @kind = params["kind"]
-    @instance = params["instance"]
-    content_type :svg
-    create_graph_one(db, @kind, @instance, :draw_svg)
+    serve_vue
   end
   get "/kinds/:kind/instances/:instance/dot" do
     @kind = params["kind"]
     @instance = params["instance"]
     content_type "text/plain"
-    create_graph_one(db, @kind, @instance, :draw_dot)
-  end
-  # Execute an Analysis and return HTML results
-  post "/kinds/Analysis/instances/:instance/execute" do
-    require "archsight/analysis"
-    @instance = params["instance"]
-    analysis = db.instance_by_kind("Analysis", @instance)
-    unless analysis
-      return haml_inline('.analysis-error
-  %i.iconoir-warning-triangle
-  Analysis not found: #{@instance}')
-    end
-    executor = Archsight::Analysis::Executor.new(db)
-    result = executor.execute(analysis)
-    haml :"partials/instance/_analysis_result", locals: { result: result }
-  end
-  private
-  # Helper for inline HAML rendering
-  def haml_inline(template)
-    haml template
+    create_graph_one(db, @kind, @instance)
   end
 end

data/lib/archsight/web/editor/helpers.rb ADDED Viewed

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+require_relative "../../editor"
+require_relative "form_builder"
+module Archsight
+  module Web
+    module Editor
+      # Shared helpers for editor routes
+      module Helpers
+        # Get form fields for a resource kind
+        def editor_fields(kind)
+          FormBuilder.fields_for(kind)
+        end
+        # Get available relations for a resource kind
+        def available_relations(kind)
+          Archsight::Editor.available_relations(kind)
+        end
+        # Extract annotations from JSON body or form params
+        def extract_annotations(params)
+          annotations = params["annotations"] || {}
+          annotations.transform_values { |v| v.is_a?(String) ? v.strip : v }
+        end
+        # Parse relations from JSON array format
+        # Accepts: [{ verb, kind, names: [...] }] or [{ verb, kind, name }]
+        def parse_json_relations(relations_data)
+          return [] unless relations_data.is_a?(Array)
+          relations_data.each_with_object([]) do |rel, result|
+            next unless rel.is_a?(Hash)
+            parsed = parse_single_relation(rel)
+            next unless parsed
+            merge_relation(result, parsed)
+          end
+        end
+        # Validate content hash for optimistic locking
+        def validate_content_hash(instance, expected_hash)
+          Archsight::Editor::ContentHasher.validate(
+            path: instance.path_ref.path,
+            start_line: instance.path_ref.line_no,
+            expected_hash: expected_hash
+          )
+        end
+        # Build form metadata response for a kind
+        def build_form_metadata(kind, klass)
+          {
+            kind: kind,
+            icon: klass.icon,
+            layer: klass.layer,
+            fields: serialize_fields(kind),
+            relation_options: build_relation_options(kind),
+            instances_by_kind: build_instances_by_kind(kind),
+            inline_edit_enabled: settings.inline_edit_enabled
+          }
+        end
+        # Extract relations from an existing instance into form format
+        def extract_instance_relations(instance)
+          relations = []
+          instance.spec.each do |verb, relation_groups|
+            next unless relation_groups.is_a?(Hash)
+            relation_groups.each do |relation_name, targets|
+              next unless targets.is_a?(Array)
+              target_class = Archsight::Editor.target_class_for_relation(instance.kind, verb, relation_name)
+              next unless target_class
+              targets.each do |target|
+                target_name = target.respond_to?(:name) ? target.name : target.to_s
+                relations << { verb: verb, kind: target_class, name: target_name }
+              end
+            end
+          end
+          relations
+        end
+        private
+        def parse_single_relation(rel)
+          verb = (rel["verb"] || rel[:verb])&.to_s&.strip
+          kind = (rel["kind"] || rel[:kind])&.to_s&.strip
+          return if verb.nil? || verb.empty? || kind.nil? || kind.empty?
+          names = extract_relation_names(rel)
+          return if names.empty?
+          { verb: verb, kind: kind, names: names }
+        end
+        def extract_relation_names(rel)
+          names = rel["names"] || rel[:names]
+          name = rel["name"] || rel[:name]
+          if names.is_a?(Array)
+            names.map(&:to_s).reject(&:empty?)
+          elsif name
+            [name.to_s.strip].reject(&:empty?)
+          else
+            []
+          end
+        end
+        def merge_relation(relations, parsed)
+          existing = relations.find { |r| r[:verb] == parsed[:verb] && r[:kind] == parsed[:kind] }
+          if existing
+            parsed[:names].each { |n| existing[:names] << n unless existing[:names].include?(n) }
+          else
+            relations << parsed
+          end
+        end
+        def serialize_fields(kind)
+          editor_fields(kind).map do |f|
+            {
+              key: f.key, title: f.title, description: f.description,
+              input_type: f.input_type.to_s, options: f.options, step: f.step,
+              required: f.required, code_language: f.code_language&.to_s
+            }
+          end
+        end
+        def build_relation_options(kind)
+          available_relations(kind)
+            .map { |v, _, k| { combo: "#{v}:#{k}", verb: v.to_s, target_kind: k.to_s } }
+            .sort_by { |r| r[:combo] }
+            .uniq { |r| r[:combo] }
+        end
+        def build_instances_by_kind(kind)
+          target_kinds = build_relation_options(kind).map { |r| r[:target_kind] }.uniq
+          target_kinds.each_with_object({}) do |k, h|
+            h[k] = db.instances_by_kind(k).keys.sort
+          rescue StandardError
+            h[k] = []
+          end
+        end
+      end
+    end
+  end
+end