archsight 0.1.4 → 0.2.0

data/lib/archsight/import/team_matcher.rb

@@ -15,11 +15,16 @@ class Archsight::Import::TeamMatcher
   # Teams to ignore when matching (bots, unknown, etc.)
   IGNORED_TEAMS = %w[Bot:Team No:Team Team:Unknown Team:Bot].freeze
 
-  def initialize(database)
+  # Team annotation keys that contain member/lead information
+  TEAM_ANNOTATION_KEYS = %w[team/members team/lead].freeze
+
+  def initialize(database, corporate_affixes: [])
     @database = database
+    @corporate_affixes = corporate_affixes
     @teams = load_teams
     @email_to_team = build_email_index
     @name_to_team = build_name_index
+    @member_identities = build_member_identities
   end
 
   # Analyze top contributors and return team assignments
@@ -72,6 +77,12 @@ class Archsight::Import::TeamMatcher
       return team if team
     end
 
+    # Try corporate username pattern match (e.g. jsmith-ionos -> John Smith)
+    if name
+      team = pattern_match_username(name)
+      return team if team
+    end
+
     nil
   end
 
@@ -87,21 +98,22 @@ class Archsight::Import::TeamMatcher
     end
   end
 
-  def build_email_index
-    index = {}
-
+  # Yields (team_name, annotation_value) for each team/members and team/lead annotation
+  def each_team_annotation
     @teams.each do |team|
       team_name = team.name
-
-      # Extract emails from team/members annotation
-      members = team.annotations["team/members"]
-      parse_email_list(members).each do |email|
-        index[email.downcase] = team_name
+      TEAM_ANNOTATION_KEYS.each do |key|
+        value = team.annotations[key]
+        yield team_name, value if value && !value.empty?
       end
+    end
+  end
+
+  def build_email_index
+    index = {}
 
-      # Extract email from team/lead annotation
-      lead = team.annotations["team/lead"]
-      parse_email_list(lead).each do |email|
+    each_team_annotation do |team_name, value|
+      parse_email_list(value).each do |email|
         index[email.downcase] = team_name
       end
     end
@@ -112,19 +124,8 @@ class Archsight::Import::TeamMatcher
   def build_name_index
     index = {}
 
-    @teams.each do |team|
-      team_name = team.name
-
-      # Extract names from team/members annotation
-      members = team.annotations["team/members"]
-      parse_name_list(members).each do |name|
-        normalized = normalize_name(name)
-        index[normalized] = team_name if normalized && !normalized.empty?
-      end
-
-      # Extract name from team/lead annotation
-      lead = team.annotations["team/lead"]
-      parse_name_list(lead).each do |name|
+    each_team_annotation do |team_name, value|
+      parse_name_list(value).each do |name|
         normalized = normalize_name(name)
         index[normalized] = team_name if normalized && !normalized.empty?
       end
@@ -136,60 +137,109 @@ class Archsight::Import::TeamMatcher
   # Parse email addresses from team annotation
   # Supports formats: "Name <email>", "email", or comma/newline separated lists
   def parse_email_list(value)
-    return [] if value.nil? || value.empty?
+    parse_name_email_pairs(value).filter_map { |pair| pair[:email] }
+  end
 
-    emails = []
+  # Parse names from team annotation
+  # Supports formats: "Name <email>", "First Last", or comma/newline separated lists
+  def parse_name_list(value)
+    parse_name_email_pairs(value).filter_map { |pair| pair[:name] }
+  end
 
-    # Split by comma or newline
-    value.split(/[,\n]/).each do |entry|
-      entry = entry.strip
-      next if entry.empty?
+  # Normalize name for matching
+  # Converts to lowercase, removes extra spaces, handles common variations
+  def normalize_name(name)
+    return nil if name.nil?
 
-      # Try to extract email from "Name <email>" format
-      if (match = entry.match(/<([^>]+)>/))
-        emails << match[1].strip
-      elsif entry.include?("@")
-        # Plain email address
-        emails << entry
+    name.to_s
+        .downcase
+        .gsub(/\s+/, " ")
+        .strip
+  end
+
+  # Match git author name as corporate username pattern {first_initial}{lastname}[-affix] or [affix-]{first_initial}{lastname}
+  # e.g. "jsmith-ionos" or "ionos-jsmith" -> initial "j", lastname "smith" -> matches "John Smith"
+  #
+  # Limitations: Multi-part names (e.g. "Hans von Braun") only match by the last
+  # name part ("braun"), so "hvonbraun" would not match. Hyphenated lastnames
+  # (e.g. "Meyer-Schmidt") only match the full hyphenated form or the email lastname.
+  def pattern_match_username(name)
+    username = name.downcase.strip
+    return nil unless username.match?(/\A[a-z0-9][-a-z0-9]*\z/)
+    return nil if @corporate_affixes.empty?
+
+    @corporate_affixes.each do |affix|
+      clean = affix.delete_prefix("-").delete_suffix("-")
+      username = username.delete_suffix("-#{clean}")
+      username = username.delete_prefix("#{clean}-")
+    end
+    return nil if username.length < 3
+
+    initial = username[0]
+    lastname = username[1..]
+    return nil if lastname.length < 3
+
+    candidates = @member_identities.select do |member|
+      lastname_match = member[:lastname] == lastname || member[:email_lastname] == lastname
+      initial_match = member[:firstname]&.start_with?(initial)
+      lastname_match && initial_match
+    end
+
+    teams = candidates.map { |c| c[:team] }.uniq
+    return teams.first if teams.size == 1
+
+    nil
+  end
+
+  # Build identity records for corporate username pattern matching
+  def build_member_identities
+    identities = []
+
+    each_team_annotation do |team_name, value|
+      parse_name_email_pairs(value).each do |entry|
+        name_parts = entry[:name]&.downcase&.split(/\s+/)
+        next if name_parts.nil? || name_parts.size < 2
+
+        firstname = name_parts.first
+        lastname = name_parts.last
+
+        email_prefix = entry[:email]&.split("@")&.first
+        email_parts = email_prefix&.split(/[.-]/)
+        email_lastname = email_parts&.last&.downcase
+
+        identities << { team: team_name, firstname: firstname, lastname: lastname, email_lastname: email_lastname }
       end
     end
 
-    emails
+    identities
   end
 
-  # Parse names from team annotation
-  # Supports formats: "Name <email>", "First Last", or comma/newline separated lists
-  def parse_name_list(value)
+  # Parse name and email pairs from team annotation
+  # Returns array of { name:, email: } hashes from "Name <email>" format
+  def parse_name_email_pairs(value)
     return [] if value.nil? || value.empty?
 
-    names = []
+    pairs = []
 
-    # Split by comma or newline
     value.split(/[,\n]/).each do |entry|
       entry = entry.strip
       next if entry.empty?
 
-      # Try to extract name from "Name <email>" format
-      if (match = entry.match(/^([^<]+)</))
+      name = nil
+      email = nil
+
+      if (match = entry.match(/^([^<]+)<([^>]+)>/))
         name = match[1].strip
-        names << name unless name.empty?
-      elsif !entry.include?("@")
-        # Plain name (no email)
-        names << entry
+        email = match[2].strip
+      elsif entry.include?("@")
+        email = entry.strip
+      else
+        name = entry.strip
       end
-    end
-
-    names
-  end
 
-  # Normalize name for matching
-  # Converts to lowercase, removes extra spaces, handles common variations
-  def normalize_name(name)
-    return nil if name.nil?
+      pairs << { name: name, email: email } if name || email
+    end
 
-    name.to_s
-        .downcase
-        .gsub(/\s+/, " ")
-        .strip
+    pairs
   end
 end

data/lib/archsight/linter.rb

@@ -4,7 +4,7 @@ require "kramdown"
 
 module Archsight
   class Linter
-    # Available view components (partials in views/partials/components/)
+    # Valid @component references in View annotations
     VALID_COMPONENTS = %w[activity git jira languages owner repositories status].freeze
 
     def initialize(database)

data/lib/archsight/mcp/base.rb

@@ -27,6 +27,17 @@ module Archsight::MCP
       result
     end
 
+    def annotations_summary(resource, omit_kind: false)
+      result = {
+        name: resource.name,
+        metadata: {
+          annotations: resource.annotations
+        }
+      }
+      result[:kind] = resource.class.to_s.split("::").last unless omit_kind
+      result
+    end
+
     def extract_description(resource)
       description = resource.annotations["architecture/description"]
       return "No description" if description.nil?

data/lib/archsight/mcp/execute_analysis_tool.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+class Archsight::MCP::ExecuteAnalysisTool < FastMcp::Tool
+  tool_name "execute_analysis"
+
+  description <<~DESC.gsub("\n", " ").strip
+    Discover and execute Analysis resources that validate architecture data and produce reports.
+
+    TWO MODES OF OPERATION:
+
+    1. LIST MODE (no name): Returns all available Analysis resources with name, description,
+       handler, and timeout. Use this to discover what analyses exist before running them.
+
+    2. EXECUTE MODE (name provided): Runs the specified Analysis script in a sandboxed environment
+       and returns the results as markdown. The output includes structured findings like tables,
+       lists, warnings, and errors generated by the script.
+  DESC
+
+  arguments do
+    optional(:name).filled(:string).description(
+      "Analysis name to execute (e.g., 'Analysis:Service:TeamOwnership'). " \
+      "Omit to list all available analyses."
+    )
+    optional(:verbose).filled(:bool).description(
+      "When true, tables and lists in output are not truncated. Default: false."
+    )
+  end
+
+  def call(name: nil, verbose: false)
+    if name.nil?
+      list_analyses
+    else
+      execute_analysis(name, verbose: verbose)
+    end
+  rescue StandardError => e
+    error_response(e.message)
+  end
+
+  private
+
+  def list_analyses
+    db = Archsight::MCP.db
+    analyses = db.instances_by_kind("Analysis").values
+
+    resources = analyses.map do |analysis|
+      {
+        name: analysis.name,
+        description: analysis.annotations["analysis/description"] || analysis.annotations["architecture/description"],
+        handler: analysis.annotations["analysis/handler"] || "ruby",
+        timeout: analysis.annotations["analysis/timeout"] || "30s"
+      }
+    end
+
+    JSON.pretty_generate(
+      total: resources.size,
+      analyses: resources
+    )
+  end
+
+  def execute_analysis(name, verbose: false)
+    require "archsight/analysis"
+
+    db = Archsight::MCP.db
+    analysis = db.instance_by_kind("Analysis", name)
+    return error_response("Analysis not found: #{name}") unless analysis
+
+    executor = Archsight::Analysis::Executor.new(db)
+    result = executor.execute(analysis)
+
+    if result.success?
+      JSON.pretty_generate(
+        name: result.name,
+        success: true,
+        duration: result.duration,
+        output: result.to_markdown(verbose: verbose),
+        has_findings: result.has_findings?,
+        warning_count: result.warning_count,
+        error_count: result.error_count
+      )
+    else
+      response = {
+        name: result.name,
+        success: false,
+        error: result.error
+      }
+      partial = result.to_markdown(verbose: verbose)
+      response[:partial_output] = partial unless partial.empty?
+      JSON.pretty_generate(response)
+    end
+  end
+
+  def error_response(message)
+    JSON.pretty_generate(
+      error: "Error",
+      message: message
+    )
+  end
+end

data/lib/archsight/mcp.rb

@@ -4,3 +4,4 @@ require_relative "mcp/base"
 require_relative "mcp/query_tool"
 require_relative "mcp/analyze_resource_tool"
 require_relative "mcp/resource_doc_tool"
+require_relative "mcp/execute_analysis_tool"

data/lib/archsight/renderer.rb

@@ -49,7 +49,7 @@ module Archsight
       graph.edge gname(a_inst), gname(b_inst), label: label, fontname: "#{FONT} italic"
     end
 
-    def create_graph_all(db, method = :draw_dot, root_kinds: nil, max_depth: 3, allowed_kinds: nil)
+    def create_graph_all(db, root_kinds: nil, max_depth: 3, allowed_kinds: nil)
       root_kinds ||= [Archsight::Resources["BusinessProduct"], Archsight::Resources["BusinessProcess"]]
 
       # Default allowed kinds for overview: Products, Processes, Services, and Teams
@@ -61,7 +61,7 @@ module Archsight
       ]
       allowed_kinds_set = allowed_kinds.to_set
 
-      Archsight::Graphvis.new("all").send(method) do |g|
+      Archsight::Graphvis.new("all").draw_dot do |g|
         nodes = {} # Track visited nodes
         edges = {} # Track created edges
 
@@ -104,11 +104,11 @@ module Archsight
       end
     end
 
-    def create_graph_one(db, klass_pat, name_pat, method = :draw_dot)
+    def create_graph_one(db, klass_pat, name_pat)
       name = "#{klass_pat}:#{name_pat}"
       nodes = {}
       edges = {}
-      Archsight::Graphvis.new(name).send(method) do |g|
+      Archsight::Graphvis.new(name).draw_dot do |g|
         klass = Archsight::Resources[klass_pat] || raise("kind #{klass_pat} unknown")
         instances = db.instances[klass]
         inst = instances[name_pat] || raise("name #{name_pat} for kind #{klass_pat} not found")

data/lib/archsight/resources/analysis.rb

@@ -51,6 +51,7 @@ class Archsight::Resources::Analysis < Archsight::Resources::Base
   annotation "analysis/script",
              description: "Ruby script to execute in sandboxed environment",
              title: "Script",
+             format: :ruby,
              sidebar: false
 
   # Description
@@ -63,23 +64,6 @@ class Archsight::Resources::Analysis < Archsight::Resources::Base
              description: "Maximum execution time (e.g., '30s', '5m')",
              title: "Timeout"
 
-  # Output configuration
-  annotation "analysis/output",
-             description: "Output mode for results",
-             title: "Output",
-             enum: %w[console file]
-
-  annotation "analysis/outputPath",
-             description: "File path for output (when output mode is 'file')",
-             title: "Output Path",
-             sidebar: false
-
-  # Enabled flag
-  annotation "analysis/enabled",
-             description: "Whether this analysis is enabled",
-             title: "Enabled",
-             enum: %w[true false]
-
   # Pattern annotation for custom configuration
   annotation "analysis/config/*",
              description: "Custom configuration values for the analysis script",

data/lib/archsight/resources/application_interface.rb

@@ -2,7 +2,7 @@
 
 # ApplicationInterface between ApplicationComponent
 class Archsight::Resources::ApplicationInterface < Archsight::Resources::Base
-  include_annotations :git, :architecture, :generated
+  include_annotations :git, :architecture, :interface, :generated
 
   description <<~MD
     Represents a point of access where application services are made available.
@@ -39,10 +39,6 @@ class Archsight::Resources::ApplicationInterface < Archsight::Resources::Base
              description: "API authentication method",
              title: "API Authentication Method",
              enum: ["none", "hard coded", "token", "oidc"]
-  annotation "api/authenticationProvider",
-             description: "API authentication provider",
-             title: "API Authentication Provider",
-             enum: %w[eiam cloud custom]
   annotation "api/authorization",
              description: "API authorization mechanism",
              title: "API Authorization",

data/lib/archsight/resources/base.rb

@@ -15,7 +15,7 @@ module Archsight
       end
 
       def self.relation(verb, kind, klass_name)
-        @relations ||= []
+        @relations ||= [] #: Array[[Symbol, Symbol, String]]
         @relations << [verb, kind, klass_name]
       end
 
@@ -25,10 +25,10 @@ module Archsight
 
       # Define an annotation using the Annotation class
       def self.annotation(key, description: nil, filter: nil, title: nil, format: nil, enum: nil, sidebar: true,
-                          type: nil, list: false)
-        @annotations ||= []
+                          type: nil, list: false, editor: true)
+        @annotations ||= [] #: Array[Archsight::Annotations::Annotation]
         options = { description: description, filter: filter, title: title, format: format, enum: enum,
-                    sidebar: sidebar, type: type, list: list }
+                    sidebar: sidebar, type: type, list: list, editor: editor }
         @annotations << Archsight::Annotations::Annotation.new(key, options)
       end
 
@@ -51,15 +51,15 @@ module Archsight
       # @param list [Boolean] Whether values are lists (default false)
       # @yield Block that computes the annotation value, evaluated in Evaluator context
       def self.computed_annotation(key, description: nil, filter: nil, title: nil, format: nil, enum: nil,
-                                   sidebar: false, type: nil, list: false, &)
+                                   sidebar: false, type: nil, list: false, editor: true, &)
         require_relative "../annotations/computed"
-        @computed_annotations ||= []
+        @computed_annotations ||= [] #: Array[Archsight::Annotations::Computed]
         @computed_annotations << Archsight::Annotations::Computed.new(key, description: description, type: type, &)
 
         # Also register as a regular annotation so it passes validation and is recognized
-        @annotations ||= []
+        @annotations ||= [] #: Array[Archsight::Annotations::Annotation]
         options = { description: description, filter: filter, title: title, format: format, enum: enum,
-                    sidebar: sidebar, type: type, list: list }
+                    sidebar: sidebar, type: type, list: list, editor: editor }
         @annotations << Archsight::Annotations::Annotation.new(key, options)
       end
 
@@ -180,11 +180,11 @@ module Archsight
       # @param key [String] The annotation key
       # @param value [Object] The computed value
       def set_computed_annotation(key, value)
-        @computed_values ||= {}
+        @computed_values ||= {} #: Hash[String, untyped]
         @computed_values[key] = value
         # Write to annotations hash for query compatibility
         @raw["metadata"] ||= {}
-        @raw["metadata"]["annotations"] ||= {}
+        @raw["metadata"]["annotations"] = @raw["metadata"]["annotations"] || {} #: Hash[String, String]
         @raw["metadata"]["annotations"][key] = value
       end
 
@@ -241,13 +241,13 @@ module Archsight
       # Get references grouped by kind and verb for display (incoming)
       # Returns: { "Kind" => { "verb" => [instances...] } }
       def references_grouped
-        grouped = {}
+        grouped = {} #: Hash[String, Hash[untyped, Array[Base]]]
         @references.each do |ref|
           inst = ref[:instance]
           verb = ref[:verb]
           kind = inst.klass
           grouped[kind] ||= {}
-          grouped[kind][verb] ||= []
+          grouped[kind][verb] ||= [] #: Array[Base]
           grouped[kind][verb] << inst
         end
         # Sort by kind name, then by verb name
@@ -257,7 +257,7 @@ module Archsight
       # Get outgoing relations grouped by verb and kind for display
       # Returns: { "verb" => { "Kind" => [instances...] } }
       def relations_grouped
-        grouped = {}
+        grouped = {} #: Hash[String, Hash[String, Array[Base]]]
         spec.each do |verb, kinds|
           next unless kinds.is_a?(Hash)
 
@@ -267,7 +267,7 @@ module Archsight
             instances.each do |inst|
               kind = inst.klass
               grouped[verb] ||= {}
-              grouped[verb][kind] ||= []
+              grouped[verb][kind] ||= [] #: Array[Base]
               grouped[verb][kind] << inst
             end
           end

data/lib/archsight/resources/business_actor.rb

@@ -43,7 +43,7 @@ class Archsight::Resources::BusinessActor < Archsight::Resources::Base
              title: "Team Members",
              sidebar: false,
              filter: :list,
-             format: :tag_list,
+             format: :multiline,
              type: Archsight::Annotations::EmailRecipient
 
   annotation "team/jira",
@@ -181,7 +181,7 @@ class Archsight::Resources::BusinessActor < Archsight::Resources::Base
 
   computed_annotation "jira/projectUrl",
                       title: "Jira Board",
-                      description: "Link to Jira board (computed from team/jira)",
+                      description: "Link to Jira board (computed from team/jira and Import host config)",
                       format: :link do
     jira_key = @instance.annotations["team/jira"]
     next nil if jira_key.nil? || jira_key.empty?
@@ -190,6 +190,21 @@ class Archsight::Resources::BusinessActor < Archsight::Resources::Base
     primary_key = jira_key.split(/[,\n]/).first&.strip
     next nil if primary_key.nil? || primary_key.empty?
 
-    "https://jira.example.com/projects/#{primary_key}/issues"
+    # Find Jira host from Import resources with a Jira handler
+    jira_host = nil
+    imports = @database.instances_by_kind("Import")
+    imports.each_value do |imp|
+      handler = imp.annotations["import/handler"]
+      next unless handler&.match?(/\AJira/i)
+
+      host = imp.annotations["import/config/host"]
+      if host && !host.empty?
+        jira_host = host
+        break
+      end
+    end
+    next nil unless jira_host
+
+    "https://#{jira_host}/projects/#{primary_key}/issues"
   end
 end

data/lib/archsight/resources/technology_artifact.rb

@@ -158,6 +158,54 @@ class Archsight::Resources::TechnologyArtifact < Archsight::Resources::Base
              title: "Deployment Container Privileges",
              enum: %w[unprivileged privileged]
 
+  # License information
+  annotation "license/spdx",
+             description: "SPDX license identifier",
+             title: "License",
+             filter: :word,
+             sidebar: false,
+             enum: %w[Apache-2.0 MIT BSD-3-Clause BSD-2-Clause GPL-3.0 GPL-2.0 LGPL-3.0
+                      LGPL-2.1 MPL-2.0 ISC AGPL-3.0 Unlicense CC0-1.0 BSL-1.0 EUPL-1.2
+                      0BSD CDDL-1.0 Ruby NOASSERTION proprietary unknown]
+  annotation "license/file",
+             description: "License file path",
+             title: "License File",
+             sidebar: false
+  annotation "license/category",
+             description: "License category",
+             title: "License Category",
+             filter: :word,
+             enum: %w[permissive copyleft weak-copyleft proprietary unknown]
+  annotation "license/dependencies/count",
+             description: "Total dependencies",
+             title: "Dependencies",
+             type: Integer
+  annotation "license/dependencies/ecosystems",
+             description: "Detected dependency ecosystems",
+             title: "Ecosystems",
+             filter: :list,
+             sidebar: false
+  annotation "license/dependencies/licenses",
+             description: "Dependency license types",
+             title: "Dependency Licenses",
+             filter: :list,
+             sidebar: false
+  annotation "license/dependencies/copyleft",
+             description: "Copyleft dependencies present",
+             title: "Copyleft Dependencies",
+             filter: :word,
+             sidebar: false,
+             enum: %w[true false unknown]
+  annotation "license/dependencies/risk",
+             description: "License risk level",
+             title: "License Risk",
+             filter: :word,
+             sidebar: false,
+             enum: %w[low weak-copyleft copyleft unknown]
+  annotation "license/dependencies/*/count",
+             description: "Dependencies per license type",
+             sidebar: false
+
   # Contributor metrics (unique counts, stored during import)
   annotation "activity/contributors/6m",
              title: "Contributors (6 months)",

data/lib/archsight/resources/technology_interface.rb

@@ -2,7 +2,7 @@
 
 # TechnologyInterface is the backing of an applicationInterface
 class Archsight::Resources::TechnologyInterface < Archsight::Resources::Base
-  include_annotations :git, :architecture
+  include_annotations :git, :architecture, :interface
 
   description <<~MD
     Represents a point of access where technology services are made available.

data/lib/archsight/resources/technology_service.rb

@@ -30,6 +30,11 @@ class Archsight::Resources::TechnologyService < Archsight::Resources::Base
   icon "cloud"
   layer "technology"
 
+  annotation "architecture/applicationSets",
+             description: "Related ArgoCD ApplicationSets",
+             title: "ApplicationSets",
+             format: :markdown
+
   relation :suppliedBy, :technologyComponents, :TechnologySystemSoftware
   relation :servedBy, :businessActors, :BusinessActor
 end

data/lib/archsight/version.rb

@@ -4,5 +4,5 @@
 # Do not edit manually.
 
 module Archsight
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end