archsight 0.1.4 → 0.1.5

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",

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.1.5"
 end

data/lib/archsight/web/application.rb

@@ -16,6 +16,7 @@ require_relative "../resources"
 require_relative "../mcp"
 require_relative "api/routes"
 require_relative "api/docs"
+require_relative "editor/routes"
 
 # Define the Web namespace before the class definition
 module Archsight::Web; end
@@ -59,6 +60,7 @@ class Archsight::Web::Application < Sinatra::Base
     set :haml, format: :html5
     set :server, :puma
     set :reload_enabled, true
+    set :inline_edit_enabled, false
   end
 
   # MCP Server setup
@@ -74,6 +76,7 @@ class Archsight::Web::Application < Sinatra::Base
     mcp_server.register_tool(Archsight::MCP::QueryTool)
     mcp_server.register_tool(Archsight::MCP::AnalyzeResourceTool)
     mcp_server.register_tool(Archsight::MCP::ResourceDocTool)
+    mcp_server.register_tool(Archsight::MCP::ExecuteAnalysisTool)
 
     use FastMcp::Transports::RackTransport, mcp_server,
         path_prefix: "/mcp",
@@ -85,6 +88,7 @@ class Archsight::Web::Application < Sinatra::Base
   # Register API modules
   register Archsight::Web::API::Routes
   register Archsight::Web::API::Docs
+  register Archsight::Web::Editor::Routes
 
   helpers do
     def db
@@ -95,6 +99,10 @@ class Archsight::Web::Application < Sinatra::Base
       settings.reload_enabled
     end
 
+    def inline_edit_enabled?
+      settings.inline_edit_enabled
+    end
+
     def production?
       settings.environment == :production
     end

data/lib/archsight/web/doc/import.md

@@ -104,8 +104,9 @@ Lists repositories from a GitLab instance and generates child Import resources.
 - `host` - GitLab host (required)
 - `exploreGroups` - If "true", explore all visible groups (default: false)
 - `repoOutputPath` - Output path for repository handler results
-- `fallbackTeam` - Default team when no contributor match found
-- `botTeam` - Team for bot-only repositories
+- `fallbackTeam` - Default team when no contributor match found (propagated to child imports)
+- `botTeam` - Team for bot-only repositories (propagated to child imports)
+- `corporateAffixes` - Comma-separated corporate username affixes for team matching, e.g., "ionos,1and1" (propagated to child imports)
 
 **Environment:**
 - `GITLAB_TOKEN` - Personal access token (required)
@@ -119,6 +120,9 @@ Lists repositories from a GitHub organization and generates child Import resourc
 **Configuration:**
 - `org` - GitHub organization (required)
 - `repoOutputPath` - Output path for repository handler results
+- `fallbackTeam` - Default team when no contributor match found (propagated to child imports)
+- `botTeam` - Team for bot-only repositories (propagated to child imports)
+- `corporateAffixes` - Comma-separated corporate username affixes for team matching, e.g., "ionos,1and1" (propagated to child imports)
 
 **Environment:**
 - `GITHUB_TOKEN` - GitHub Personal Access Token (required)
@@ -140,6 +144,7 @@ Analyzes a single git repository and generates a TechnologyArtifact resource.
 - `sccPath` - Path to scc binary (default: scc)
 - `fallbackTeam` - Default team when no contributor match found
 - `botTeam` - Team for bot-only repositories
+- `corporateAffixes` - Comma-separated corporate username affixes for team matching (e.g., "ionos,1and1"). Enables matching git usernames like `jsmith-ionos` or `ionos-jsmith` to team member "John Smith". Without this, corporate username pattern matching is inactive.
 
 **Output:** Generates one TechnologyArtifact resource with:
 - Code analysis metrics (languages, LOC, estimated cost)
@@ -287,6 +292,7 @@ metadata:
     import/config/host: gitlab.company.com
     import/config/repoOutputPath: generated/repositories.yaml
     import/config/fallbackTeam: "Team:Platform"
+    import/config/corporateAffixes: "ionos,1and1"
 spec: {}
 ```
 
@@ -305,6 +311,8 @@ metadata:
     import/config/gitUrl: git@gitlab.company.com:company/my-service.git
     import/config/archived: "false"
     import/config/visibility: internal
+    import/config/fallbackTeam: "Team:Platform"
+    import/config/corporateAffixes: "ionos,1and1"
     import/outputPath: generated/repositories.yaml
 spec: {}
 ---

data/lib/archsight/web/editor/form_builder.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../../editor"
+
+module Archsight
+  module Web
+    module Editor
+      # FormBuilder generates form field metadata from annotation definitions
+      class FormBuilder
+        # Field represents a single form field configuration
+        Field = Struct.new(:key, :title, :description, :input_type, :options, :step, :required, :code_language, keyword_init: true) do
+          def select?
+            input_type == :select
+          end
+
+          def textarea?
+            %i[textarea markdown].include?(input_type)
+          end
+
+          def markdown?
+            input_type == :markdown
+          end
+
+          def code?
+            input_type == :code
+          end
+
+          def number?
+            input_type == :number
+          end
+
+          def url?
+            input_type == :url
+          end
+
+          def text?
+            input_type == :text
+          end
+
+          def list?
+            input_type == :list
+          end
+        end
+
+        # Build form fields for a resource kind
+        # @param kind [String] Resource kind
+        # @return [Array<Field>]
+        def self.fields_for(kind)
+          annotations = Archsight::Editor.editable_annotations(kind)
+
+          annotations.map do |ann|
+            Field.new(
+              key: ann.key,
+              title: ann.title,
+              description: ann.description,
+              input_type: determine_input_type(ann),
+              options: ann.enum,
+              step: determine_step(ann),
+              required: false,
+              code_language: ann.code_language
+            )
+          end
+        end
+
+        # Determine input type based on annotation properties
+        # @param annotation [Archsight::Annotations::Annotation]
+        # @return [Symbol]
+        def self.determine_input_type(annotation)
+          return :select if annotation.enum
+
+          case annotation.type.to_s
+          when "Integer", "Float"
+            :number
+          when "URI"
+            :url
+          else
+            return :markdown if annotation.markdown?
+            return :textarea if annotation.multiline?
+            return :code if annotation.code?
+            return :list if annotation.list?
+
+            :text
+          end
+        end
+
+        # Determine step attribute for number inputs
+        # @param annotation [Archsight::Annotations::Annotation]
+        # @return [String, nil]
+        def self.determine_step(annotation)
+          case annotation.type.to_s
+          when "Integer"
+            "1"
+          when "Float"
+            "0.01"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/archsight/web/editor/routes.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+require "sinatra/extension"
+require_relative "../../editor"
+require_relative "form_builder"
+
+module Archsight
+  module Web
+    module Editor
+      # Routes for the resource editor
+      module Routes
+        extend Sinatra::Extension
+
+        helpers do
+          # Get form fields for a resource kind
+          def editor_fields(kind)
+            FormBuilder.fields_for(kind)
+          end
+
+          # Get relation verbs for a resource kind
+          def relation_verbs(kind)
+            Archsight::Editor.relation_verbs(kind)
+          end
+
+          # Get available relations for a resource kind
+          def available_relations(kind)
+            Archsight::Editor.available_relations(kind)
+          end
+
+          # Extract annotations from form params
+          def extract_annotations(params)
+            annotations = params["annotations"] || {}
+            annotations.transform_values { |v| v.is_a?(String) ? v.strip : v }
+          end
+
+          # Extract relations from form params
+          # Relations come in as arrays: verb[], kind[], name[]
+          def parse_form_relations(params)
+            relations = []
+            relation_data = params["relations"] || []
+
+            relation_data.each do |rel|
+              next unless rel.is_a?(Hash)
+
+              verb = rel["verb"]&.strip
+              kind = rel["kind"]&.strip
+              name = rel["name"]&.strip
+
+              next if verb.nil? || verb.empty?
+              next if kind.nil? || kind.empty?
+              next if name.nil? || name.empty?
+
+              # Find existing relation group or create new one
+              existing = relations.find { |r| r[:verb] == verb && r[:kind] == kind }
+              if existing
+                existing[:names] << name unless existing[:names].include?(name)
+              else
+                relations << { verb: verb, kind: kind, names: [name] }
+              end
+            end
+
+            relations
+          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
+        end
+
+        # Create mode - empty form
+        get "/kinds/:kind/new" do
+          @kind = params["kind"]
+          @klass = Archsight::Resources[@kind]
+          halt 404, "Kind not found" unless @klass
+
+          @editor_mode = true
+          @mode = :create
+          @name = ""
+          @annotations = {}
+          @relations = []
+          @fields = editor_fields(@kind)
+          @errors = {}
+
+          haml :index
+        end
+
+        # Create mode - generate YAML
+        post "/kinds/:kind/generate" do
+          @kind = params["kind"]
+          @klass = Archsight::Resources[@kind]
+          halt 404, "Kind not found" unless @klass
+
+          @editor_mode = true
+          @mode = :create
+          @name = (params["name"] || "").strip
+          @annotations = extract_annotations(params)
+          @relations = parse_form_relations(params)
+          @fields = editor_fields(@kind)
+
+          # Validate
+          validation = Archsight::Editor.validate(@kind, name: @name, annotations: @annotations)
+
+          unless validation[:valid]
+            @errors = validation[:errors]
+            return haml :index
+          end
+
+          # Build and render YAML
+          resource = Archsight::Editor.build_resource(
+            kind: @kind,
+            name: @name,
+            annotations: @annotations,
+            relations: @relations
+          )
+
+          @generated_yaml = Archsight::Editor.to_yaml(resource)
+          @errors = {}
+
+          haml :index
+        end
+
+        # Edit mode - pre-filled form
+        get "/kinds/:kind/instances/:name/edit" do
+          @kind = params["kind"]
+          @instance_name = params["name"]
+          @klass = Archsight::Resources[@kind]
+          halt 404, "Kind not found" unless @klass
+
+          instance = db.instance_by_kind(@kind, @instance_name)
+          halt 404, "Instance not found" unless instance
+
+          @editor_mode = true
+          @mode = :edit
+          @name = instance.name
+          @annotations = instance.annotations.dup
+          @relations = extract_instance_relations(instance)
+          @fields = editor_fields(@kind)
+          @errors = {}
+
+          # Compute content hash for optimistic locking
+          original_content = Archsight::Editor::FileWriter.read_document(
+            path: instance.path_ref.path,
+            start_line: instance.path_ref.line_no
+          )
+          @content_hash = Archsight::Editor::ContentHasher.hash(original_content)
+
+          haml :index
+        end
+
+        # Edit mode - generate YAML
+        post "/kinds/:kind/instances/:name/generate" do
+          @kind = params["kind"]
+          @instance_name = params["name"]
+          @klass = Archsight::Resources[@kind]
+          halt 404, "Kind not found" unless @klass
+
+          # Get original instance for path_ref (for inline save)
+          original_instance = db.instance_by_kind(@kind, @instance_name)
+          @path_ref = original_instance&.path_ref
+
+          @editor_mode = true
+          @mode = :edit
+          @name = (params["name_field"] || @instance_name).strip
+          @annotations = extract_annotations(params)
+          @relations = parse_form_relations(params)
+          @fields = editor_fields(@kind)
+          @content_hash = params["content_hash"]
+
+          # Validate
+          validation = Archsight::Editor.validate(@kind, name: @name, annotations: @annotations)
+
+          unless validation[:valid]
+            @errors = validation[:errors]
+            return haml :index
+          end
+
+          # Build and render YAML
+          resource = Archsight::Editor.build_resource(
+            kind: @kind,
+            name: @name,
+            annotations: @annotations,
+            relations: @relations
+          )
+
+          @generated_yaml = Archsight::Editor.to_yaml(resource)
+          @errors = {}
+
+          haml :index
+        end
+
+        # Save YAML to source file (inline edit)
+        post "/api/v1/editor/kinds/:kind/instances/:name/save" do
+          content_type :json
+
+          # Check if inline edit is enabled
+          halt 403, JSON.generate({ success: false, error: "Inline edit is disabled. Start server with --inline-edit flag." }) unless settings.inline_edit_enabled
+
+          kind = params["kind"]
+          name = params["name"]
+
+          begin
+            body = JSON.parse(request.body.read)
+            yaml_content = body["yaml"]
+            expected_hash = body["content_hash"]
+          rescue JSON::ParserError
+            halt 400, JSON.generate({ success: false, error: "Invalid JSON" })
+          end
+
+          instance = db.instance_by_kind(kind, name)
+          halt 404, JSON.generate({ success: false, error: "Instance not found" }) unless instance
+
+          # Optimistic locking: verify content hasn't changed since edit started
+          if (conflict = validate_content_hash(instance, expected_hash))
+            status 409
+            return JSON.generate({ success: false }.merge(conflict))
+          end
+
+          begin
+            Archsight::Editor::FileWriter.replace_document(
+              path: instance.path_ref.path,
+              start_line: instance.path_ref.line_no,
+              new_yaml: yaml_content
+            )
+            db.reload!
+            JSON.generate({ success: true, message: "Saved to #{instance.path_ref}" })
+          rescue Archsight::Editor::FileWriter::WriteError => e
+            status 400
+            JSON.generate({ success: false, error: e.message })
+          end
+        end
+
+        # HTMX API - Get instance names for a kind (for relation dropdown)
+        get "/api/v1/editor/kinds/:kind/instances" do
+          kind = params["kind"]
+          klass = Archsight::Resources[kind]
+          halt 404, "Kind not found" unless klass
+
+          instances = db.instances_by_kind(kind).keys.sort
+
+          content_type :json
+          JSON.generate(instances)
+        end
+
+        # HTMX API - Get valid target kinds for a verb
+        get "/api/v1/editor/relation-kinds" do
+          kind = params["kind"]
+          verb = params["verb"]
+          halt 400, "Kind and verb required" unless kind && verb
+
+          target_kinds = Archsight::Editor.target_kinds_for_verb(kind, verb)
+
+          content_type :json
+          JSON.generate(target_kinds)
+        end
+
+        helpers do
+          # Extract relations from an existing instance into form format
+          # Returns relations with target class names (e.g., "BusinessActor")
+          # not relation names (e.g., "businessActors")
+          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)
+
+                # Look up the target class name from the relation definition
+                target_class = Archsight::Editor.target_class_for_relation(instance.kind, verb, relation_name)
+                next unless target_class
+
+                targets.each do |target|
+                  # Target could be an instance object or a string
+                  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
+        end
+      end
+    end
+  end
+end