archsight 0.1.4 → 0.2.0

data/lib/archsight/editor/content_hasher.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Archsight
+  module Editor
+    # ContentHasher generates SHA256 hashes for optimistic locking
+    module ContentHasher
+      module_function
+
+      # Generate a hash of YAML content for comparison
+      # Normalizes line endings before hashing to ensure consistency across platforms
+      # @param content [String] YAML content
+      # @return [String] 16-character hex hash
+      def hash(content)
+        normalized = content.gsub("\r\n", "\n").gsub("\r", "\n")
+        Digest::SHA256.hexdigest(normalized)[0, 16]
+      end
+
+      # Validate that content hasn't changed since expected_hash was computed
+      # @param path [String] File path
+      # @param start_line [Integer] Line number where document starts
+      # @param expected_hash [String, nil] Expected content hash
+      # @return [Hash, nil] Error hash with :conflict and :error keys, or nil if valid
+      def validate(path:, start_line:, expected_hash:)
+        return nil unless expected_hash
+
+        current_content = FileWriter.read_document(path: path, start_line: start_line)
+        current_hash = hash(current_content)
+
+        return nil if current_hash == expected_hash
+
+        { conflict: true, error: "Conflict: The resource has been modified. Please reload the page and try again." }
+      end
+    end
+  end
+end

data/lib/archsight/editor/file_writer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Archsight
+  module Editor
+    # FileWriter handles reading and writing YAML documents in multi-document files
+    module FileWriter
+      class WriteError < StandardError; end
+
+      module_function
+
+      # Read a YAML document from a file starting at a given line
+      # @param path [String] File path
+      # @param start_line [Integer] Line number where document starts (1-indexed)
+      # @return [String] Document content
+      # @raise [WriteError] if file not found or line out of bounds
+      def read_document(path:, start_line:)
+        raise WriteError, "File not found: #{path}" unless File.exist?(path)
+
+        lines = File.readlines(path)
+        start_idx = start_line - 1 # Convert to 0-indexed
+
+        raise WriteError, "Line #{start_line} is beyond end of file" if start_idx >= lines.length
+
+        # Find the end of this document (next --- or EOF)
+        end_idx = find_document_end(lines, start_idx)
+
+        # Extract and join the document lines
+        lines[start_idx...end_idx].join
+      end
+
+      # Replace a YAML document in a file starting at a given line
+      # @param path [String] File path
+      # @param start_line [Integer] Line number where document starts (1-indexed)
+      # @param new_yaml [String] New YAML content (without leading ---)
+      # @raise [WriteError] if file cannot be written or document not found at expected line
+      def replace_document(path:, start_line:, new_yaml:)
+        raise WriteError, "File not found: #{path}" unless File.exist?(path)
+        raise WriteError, "File not writable: #{path}" unless File.writable?(path)
+
+        lines = File.readlines(path)
+        start_idx = start_line - 1 # Convert to 0-indexed
+
+        raise WriteError, "Line #{start_line} is beyond end of file" if start_idx >= lines.length
+
+        # Find the end of this document (next --- or EOF)
+        end_idx = find_document_end(lines, start_idx)
+
+        # Build the new content
+        # Ensure new_yaml ends with a newline
+        new_yaml = "#{new_yaml}\n" unless new_yaml.end_with?("\n")
+
+        # Replace the document
+        new_lines = lines[0...start_idx] + [new_yaml] + lines[end_idx..]
+
+        # Write atomically by writing to temp file then renaming
+        File.write(path, new_lines.join)
+      end
+
+      # Find the end index of a document (the line index of the next --- or EOF)
+      # @param lines [Array<String>] File lines
+      # @param start_idx [Integer] Starting line index (0-indexed)
+      # @return [Integer] End index (exclusive - the line after the document ends)
+      def find_document_end(lines, start_idx)
+        # Start searching from the line after start_idx
+        idx = start_idx + 1
+
+        while idx < lines.length
+          # Check if this line is a document separator
+          return idx if lines[idx].strip == "---"
+
+          idx += 1
+        end
+
+        # No separator found, document goes to EOF
+        lines.length
+      end
+    end
+  end
+end

data/lib/archsight/editor.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "resources"
+require_relative "editor/file_writer"
+require_relative "editor/content_hasher"
+
+module Archsight
+  # Editor handles building and validating resources for the web editor
+  module Editor
+    module_function
+
+    # Build a resource hash from form params
+    # @param kind [String] Resource kind (e.g., "TechnologyArtifact")
+    # @param name [String] Resource name
+    # @param annotations [Hash] Annotation key-value pairs
+    # @param relations [Array<Hash>] Array of {verb:, kind:, names:[]} hashes
+    #   where kind is the target class name (e.g., "TechnologyArtifact")
+    # @return [Hash] Resource hash ready for YAML conversion
+    def build_resource(kind:, name:, annotations: {}, relations: [])
+      resource = {
+        "apiVersion" => "architecture/v1alpha1",
+        "kind" => kind,
+        "metadata" => {
+          "name" => name
+        }
+      }
+
+      # Add annotations if any non-empty values exist
+      filtered_annotations = filter_empty(annotations)
+      resource["metadata"]["annotations"] = filtered_annotations unless filtered_annotations.empty?
+
+      # Add spec with relations if any exist
+      spec = build_spec(kind, relations)
+      resource["spec"] = spec unless spec.empty?
+
+      resource
+    end
+
+    # Validate resource params using annotation definitions
+    # @param kind [String] Resource kind
+    # @param name [String] Resource name
+    # @param annotations [Hash] Annotation key-value pairs
+    # @return [Hash] { valid: Boolean, errors: { field => [messages] } }
+    def validate(kind, name:, annotations: {})
+      klass = Archsight::Resources[kind]
+      errors = {}
+
+      # Validate name
+      if name.nil? || name.strip.empty?
+        errors["name"] = ["Name is required"]
+      elsif name =~ /\s/
+        errors["name"] = ["Name cannot contain spaces"]
+      end
+
+      # Validate annotations against their definitions
+      klass.annotations.reject(&:pattern?).each do |ann|
+        value = annotations[ann.key]
+        next if value.nil? || value.to_s.strip.empty?
+
+        ann_errors = ann.validate(value)
+        errors[ann.key] = ann_errors if ann_errors.any?
+      end
+
+      { valid: errors.empty?, errors: errors }
+    end
+
+    # Generate YAML string from resource hash
+    # Uses custom YAML dump that formats multiline strings with literal block scalars
+    # @param resource_hash [Hash] Resource hash
+    # @return [String] YAML string
+    def to_yaml(resource_hash)
+      visitor = Psych::Visitors::YAMLTree.create
+      visitor << resource_hash
+
+      # Walk the AST and apply scalar style for multiline strings
+      ast = visitor.tree
+      apply_block_scalar_style(ast)
+
+      ast.yaml(nil, line_width: 80)
+    end
+
+    # Recursively apply literal block style for multiline strings in YAML AST
+    # @param node [Psych::Nodes::Node] YAML AST node
+    def apply_block_scalar_style(node)
+      case node
+      when Psych::Nodes::Scalar
+        if node.value.is_a?(String)
+          # Normalize Windows/old Mac line endings to Unix style
+          node.value = node.value.gsub("\r\n", "\n").gsub("\r", "\n") if node.value.include?("\r")
+          # Use literal block style for multiline strings
+          node.style = Psych::Nodes::Scalar::LITERAL if node.value.include?("\n")
+        end
+      when Psych::Nodes::Sequence, Psych::Nodes::Mapping, Psych::Nodes::Document, Psych::Nodes::Stream
+        node.children.each { |child| apply_block_scalar_style(child) }
+      end
+    end
+
+    # Get editable annotations for a resource kind
+    # Excludes pattern annotations, computed annotations, and annotations with editor: false
+    # @param kind [String] Resource kind
+    # @return [Array<Archsight::Annotations::Annotation>]
+    def editable_annotations(kind)
+      klass = Archsight::Resources[kind]
+      return [] unless klass
+
+      # Get all annotations except pattern annotations
+      annotations = klass.annotations.reject(&:pattern?)
+
+      # Filter out computed annotations
+      computed_keys = klass.computed_annotations.map(&:key)
+      annotations = annotations.reject { |a| computed_keys.include?(a.key) }
+
+      # Filter out non-editable annotations
+      annotations.reject { |a| a.editor == false }
+    end
+
+    # Get available relations for a resource kind
+    # @param kind [String] Resource kind
+    # @return [Array<Array>] Array of [verb, target_kind, target_class_name]
+    def available_relations(kind)
+      klass = Archsight::Resources[kind]
+      return [] unless klass
+
+      klass.relations
+    end
+
+    # Get unique verbs for a resource kind's relations
+    # @param kind [String] Resource kind
+    # @return [Array<String>]
+    def relation_verbs(kind)
+      available_relations(kind).map { |v, _, _| v.to_s }.uniq.sort
+    end
+
+    # Get valid target class names for a given verb (for UI display and instance lookup)
+    # @param kind [String] Resource kind
+    # @param verb [String] Relation verb
+    # @return [Array<String>] Target class names (e.g., "TechnologyArtifact")
+    def target_kinds_for_verb(kind, verb)
+      # Relations structure is [verb, relation_name, target_class_name]
+      available_relations(kind)
+        .select { |v, _, _| v.to_s == verb.to_s }
+        .map { |_, _, target_class| target_class.to_s }
+        .uniq
+        .sort
+    end
+
+    # Get relation name for a given verb and target class (for building spec)
+    # @param kind [String] Source resource kind
+    # @param verb [String] Relation verb
+    # @param target_class [String] Target class name
+    # @return [String, nil] Relation name (e.g., "technologyComponents")
+    def relation_name_for(kind, verb, target_class)
+      relation = available_relations(kind).find do |v, _, tc|
+        v.to_s == verb.to_s && tc.to_s == target_class.to_s
+      end
+      return nil unless relation
+
+      relation[1].to_s
+    end
+
+    # Get target class name for a given verb and relation name (reverse lookup)
+    # @param kind [String] Source resource kind
+    # @param verb [String] Relation verb
+    # @param relation_name [String] Relation name (e.g., "businessActors")
+    # @return [String, nil] Target class name (e.g., "BusinessActor")
+    def target_class_for_relation(kind, verb, relation_name)
+      relation = available_relations(kind).find do |v, rn, _|
+        v.to_s == verb.to_s && rn.to_s == relation_name.to_s
+      end
+      return nil unless relation
+
+      relation[2].to_s
+    end
+
+    # Filter out empty values from a hash and convert to plain Hash
+    # (avoids !ruby/hash:Sinatra::IndifferentHash in YAML output)
+    def filter_empty(hash)
+      return {} if hash.nil?
+
+      result = hash.reject { |_, v| v.nil? || v.to_s.strip.empty? }
+      # Convert to plain Hash to avoid Ruby-specific YAML tags
+      result.to_h
+    end
+
+    # Build spec hash from relations array
+    # @param source_kind [String] The source resource kind
+    # @param relations [Array<Hash>] Array of {verb:, kind:, names:[]} hashes
+    #   where kind is the target class name (e.g., "TechnologyArtifact")
+    # @return [Hash] Spec hash with proper relation_name keys
+    def build_spec(source_kind, relations)
+      return {} if relations.nil? || relations.empty?
+
+      spec = {}
+      relations.each { |rel| add_relation_to_spec(spec, source_kind, rel) }
+      deduplicate_spec_values(spec)
+    end
+
+    def add_relation_to_spec(spec, source_kind, rel)
+      verb, target_class, names = extract_relation_parts(rel)
+      return if invalid_relation?(verb, target_class, names)
+
+      rel_name = relation_name_for(source_kind, verb, target_class)
+      return unless rel_name
+
+      spec[verb.to_s] ||= {}
+      spec[verb.to_s][rel_name] ||= []
+      spec[verb.to_s][rel_name].concat(names)
+    end
+
+    def extract_relation_parts(rel)
+      verb = rel[:verb] || rel["verb"]
+      target_class = rel[:kind] || rel["kind"]
+      names = normalize_names(rel[:names] || rel["names"] || [])
+      [verb, target_class, names]
+    end
+
+    def normalize_names(names)
+      names = [names] unless names.is_a?(Array)
+      names.map(&:to_s).reject(&:empty?)
+    end
+
+    def invalid_relation?(verb, target_class, names)
+      verb.nil? || verb.to_s.strip.empty? ||
+        target_class.nil? || target_class.to_s.strip.empty? ||
+        names.empty?
+    end
+
+    def deduplicate_spec_values(spec)
+      spec.transform_values { |kinds| kinds.transform_values(&:uniq) }
+    end
+
+    private_class_method :filter_empty, :build_spec, :add_relation_to_spec,
+                         :extract_relation_parts, :normalize_names, :invalid_relation?,
+                         :deduplicate_spec_values
+  end
+end

data/lib/archsight/graph.rb

@@ -3,33 +3,17 @@
 module Archsight
   # Graphvis implements a graphviz abstraction
   class Graphvis
-    def initialize(name, renderer = :dot, attrs = {})
+    def initialize(name, attrs = {})
       @name = name
-      @renderer = renderer.to_s
       @attrs = { rankdir: :LR }.merge(attrs)
     end
 
-    def draw_and_render_file(&)
-      File.open("#{@name}.dot", "w") do |f|
-        render(f, &)
-      end
-      system "#{@renderer} -Tpng #{@name}.dot -o #{@name}.png"
-    end
-
     def draw_dot(&)
       f = StringIO.new
       render(f, &)
       f.string
     end
 
-    def draw_svg(&)
-      IO.popen([@renderer, "-Tsvg"], "r+") do |pipe|
-        render(pipe, &)
-        pipe.close_write
-        pipe.read
-      end
-    end
-
     def render(file)
       @file = file
       file.puts "digraph G {"
@@ -76,38 +60,4 @@ module Archsight
       @file.puts "  }"
     end
   end
-
-  # GraphvisHelper for generating graphs using javascript and wasm
-  module GraphvisHelper
-    def graphviz_svg(dot, element_id)
-      format(%{
-        <script type="module">
-          import { Graphviz } from "https://cdn.jsdelivr.net/npm/@hpcc-js/wasm/dist/index.js";
-          if (Graphviz) {
-            const re =/<svg width="([^"]+)pt" height="([^"]+)pt"/;
-            const graphviz = await Graphviz.load();
-            const dot = %s;
-            let svg = graphviz.layout(dot, "svg", "dot");
-            svg = svg.replace(re, "<svg");
-            svg = svg.replace(/<polygon fill="white"[^>]*>/, "");
-            svg = svg.replace(/fill="white"/g, 'fill="none"');
-
-            const parser = new DOMParser();
-            const svgDoc = parser.parseFromString(svg, "image/svg+xml");
-            const svgElement = svgDoc.querySelector("svg");
-
-            const cssResponse = await fetch("/css/graph.css?" + Date.now());
-            const cssText = await cssResponse.text();
-            const style = document.createElementNS("http://www.w3.org/2000/svg", "style");
-            style.textContent = cssText;
-            svgElement.insertBefore(style, svgElement.firstChild);
-
-            document.getElementById(%s).innerHTML = svgElement.outerHTML;
-            // Dispatch event to notify GraphViewer that SVG is ready
-            document.dispatchEvent(new CustomEvent('graphviz:ready', { detail: { elementId: %s } }));
-          }
-        </script>
-      }, dot.inspect, element_id.inspect, element_id.inspect)
-    end
-  end
 end

data/lib/archsight/helpers.rb

@@ -64,26 +64,6 @@ module Archsight
       end
     end
 
-    # Generate htmx attributes for a custom search query
-    def search_link_attrs(query)
-      search_url = "/search?#{URI.encode_www_form(q: query)}"
-      {
-        "href" => search_url,
-        "hx-post" => "/search",
-        "hx-vals" => { q: query }.to_json,
-        "hx-swap" => "innerHTML",
-        "hx-target" => ".content",
-        "hx-push-url" => search_url
-      }
-    end
-
-    # Generate htmx attributes for filtering by annotation (convenience wrapper)
-    def filter_link_attrs(tag, value, method = "==", kind = nil)
-      query = "#{tag} #{method} \"#{value}\""
-      query = "#{kind}: #{query}" if kind
-      search_link_attrs(query)
-    end
-
     # Get icon class for a URL based on domain patterns
     def icon_for_url(url)
       case url

data/lib/archsight/import/handlers/github.rb

@@ -14,6 +14,10 @@ require_relative "../registry"
 #   import/config/org - GitHub organization name
 #   import/config/repoOutputPath - Output path for repository handler results (e.g., "generated/repositories.yaml")
 #   import/config/childCacheTime - Cache time for generated child imports (e.g., "1h", "30m")
+#   import/config/fallbackTeam - Default team when no contributor match found (propagated to child imports)
+#   import/config/botTeam - Team for bot-only repositories (propagated to child imports)
+#   import/config/corporateAffixes - Comma-separated corporate username affixes for team matching (propagated to child imports)
+#   import/config/defaultVisibility - Default visibility for non-public repos (default: "internal")
 #
 # Environment:
 #   GITHUB_TOKEN - GitHub Personal Access Token (required)
@@ -35,6 +39,7 @@ class Archsight::Import::Handlers::Github < Archsight::Import::Handler
 
     @repo_output_path = config("repoOutputPath")
     @child_cache_time = config("childCacheTime")
+    @default_visibility = config("defaultVisibility", default: "internal")
     @target_dir = File.join(Dir.home, ".cache", "archsight", "git", "github", @org)
 
     # Fetch all repositories with pagination
@@ -136,15 +141,20 @@ class Archsight::Import::Handlers::Github < Archsight::Import::Handler
       child_annotations["import/outputPath"] = @repo_output_path if @repo_output_path
       child_annotations["import/cacheTime"] = @child_cache_time if @child_cache_time
 
+      child_config = {
+        "path" => repo_path,
+        "gitUrl" => git_url,
+        "archived" => repo["isArchived"].to_s,
+        "visibility" => visibility == "public" ? "open-source" : @default_visibility
+      }
+      child_config["fallbackTeam"] = config("fallbackTeam") if config("fallbackTeam")
+      child_config["botTeam"] = config("botTeam") if config("botTeam")
+      child_config["corporateAffixes"] = config("corporateAffixes") if config("corporateAffixes")
+
       import_yaml(
         name: "Import:Repo:github:#{@org}:#{repo_name}",
         handler: "repository",
-        config: {
-          "path" => repo_path,
-          "gitUrl" => git_url,
-          "archived" => repo["isArchived"].to_s,
-          "visibility" => visibility == "public" ? "open-source" : "internal"
-        },
+        config: child_config,
         annotations: child_annotations
       )
     end

data/lib/archsight/import/handlers/gitlab.rb

@@ -19,6 +19,10 @@ require_relative "../registry"
 #   import/config/sslFingerprint - SSL certificate fingerprint for pinning (SHA256, colon-separated hex)
 #   import/config/repoOutputPath - Output path for repository handler results (e.g., "generated/repositories.yaml")
 #   import/config/childCacheTime - Cache time for generated child imports (e.g., "1h", "30m")
+#   import/config/fallbackTeam - Default team when no contributor match found (propagated to child imports)
+#   import/config/botTeam - Team for bot-only repositories (propagated to child imports)
+#   import/config/corporateAffixes - Comma-separated corporate username affixes for team matching (propagated to child imports)
+#   import/config/defaultVisibility - Default visibility when API returns none (default: "internal")
 #
 # Environment:
 #   GITLAB_TOKEN - GitLab personal access token (required)
@@ -36,6 +40,7 @@ class Archsight::Import::Handlers::Gitlab < Archsight::Import::Handler
 
     @repo_output_path = config("repoOutputPath")
     @child_cache_time = config("childCacheTime")
+    @default_visibility = config("defaultVisibility", default: "internal")
 
     @target_dir = File.join(Dir.home, ".cache", "archsight", "git", "gitlab")
     @explore_groups = config("exploreGroups") == "true"
@@ -74,8 +79,9 @@ class Archsight::Import::Handlers::Gitlab < Archsight::Import::Handler
 
     # Configure SSL verification
     if @ssl_fingerprint
-      # Use certificate pinning - disable default verification, we verify fingerprint manually
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      # Use certificate pinning - verify fingerprint in callback, return false to reject
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      fingerprint_mismatch = nil
       http.verify_callback = lambda do |_preverify_ok, cert_store|
         # Get the peer certificate from the chain
         cert = cert_store.chain&.first
@@ -85,7 +91,10 @@ class Archsight::Import::Handlers::Gitlab < Archsight::Import::Handler
         fingerprint = OpenSSL::Digest::SHA256.new(cert.to_der).to_s.upcase.scan(/../).join(":")
         expected = @ssl_fingerprint.upcase
 
-        raise OpenSSL::SSL::SSLError, "Certificate fingerprint mismatch! Expected: #{expected}, Got: #{fingerprint}" if fingerprint != expected
+        if fingerprint != expected
+          fingerprint_mismatch = "Certificate fingerprint mismatch! Expected: #{expected}, Got: #{fingerprint}"
+          return false
+        end
 
         true
       end
@@ -96,7 +105,11 @@ class Archsight::Import::Handlers::Gitlab < Archsight::Import::Handler
     request = Net::HTTP::Get.new(uri)
     request["PRIVATE-TOKEN"] = @token
 
-    response = http.request(request)
+    begin
+      response = http.request(request)
+    rescue OpenSSL::SSL::SSLError => e
+      raise OpenSSL::SSL::SSLError, fingerprint_mismatch || e.message
+    end
 
     raise "GitLab API error: #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
 
@@ -177,15 +190,20 @@ class Archsight::Import::Handlers::Gitlab < Archsight::Import::Handler
       child_annotations["import/outputPath"] = @repo_output_path if @repo_output_path
       child_annotations["import/cacheTime"] = @child_cache_time if @child_cache_time
 
+      child_config = {
+        "path" => repo_path,
+        "gitUrl" => git_url,
+        "archived" => project["archived"].to_s,
+        "visibility" => project["visibility"] || @default_visibility
+      }
+      child_config["fallbackTeam"] = config("fallbackTeam") if config("fallbackTeam")
+      child_config["botTeam"] = config("botTeam") if config("botTeam")
+      child_config["corporateAffixes"] = config("corporateAffixes") if config("corporateAffixes")
+
       import_yaml(
         name: "Import:Repo:gitlab:#{dir_name}",
         handler: "repository",
-        config: {
-          "path" => repo_path,
-          "gitUrl" => git_url,
-          "archived" => project["archived"].to_s,
-          "visibility" => project["visibility"] || "internal"
-        },
+        config: child_config,
         annotations: child_annotations
       )
     end