Feature/editor (#26)

* feat: Implement editor functionality for resource creation and management

- Add JavaScript for handling relations in the editor, including adding, removing, and sorting relations.
- Create HAML partials for rendering fields, forms, relations, and YAML output in the editor.
- Implement backend logic for generating YAML from resource definitions, including validation and handling of annotations and relations.
- Add tests for editor functionality, including form rendering, validation, and YAML generation.
- Update layout to include editor styles and scripts.
- Ensure proper handling of instance details and relations in the edit mode.

* feat: Add status annotation with lifecycle options to architecture annotations

* feat: Add interface annotations for resource classes and update related resources

* feat: Add applicationSets annotation to TechnologyService for ArgoCD integration

* feat: Remove authenticationProvider annotation from ApplicationInterface

* feat: Implement markdown editor with Lexical integration and UI enhancements

* feat: Enhance annotation validation and add code support in editor

* feat: Refactor analysis filtering and remove enabled flag from analysis resources

Author: ionos-landgraf-vin

README.md

@@ -129,6 +129,33 @@ claude mcp add --transport sse ionos-architecture http://localhost:4567/mcp/sse
 - Dark mode support
 - Layer-based color scheme (Business, Application, Technology, Data)
 
+### Resource Editor
+
+Create and edit resources through the web interface:
+
+**Edit existing resource:**
+
+- Navigate to any resource detail page
+- Click the "Edit" button (only available for non-generated resources)
+- Modify annotations and relations
+- Generate YAML and copy to clipboard
+
+**Create new resource:**
+
+- Go to any kind listing (e.g., /kinds/ApplicationComponent)
+- Click "New" button
+- Fill in required fields
+- Add relations using cascading dropdowns
+- Generate YAML and copy to clipboard
+
+The editor supports:
+
+- Type-aware form fields (dropdowns for enums, number inputs, URL validation)
+- Markdown textarea for descriptions
+- Relation management with cascading dropdowns
+- Validation before YAML generation
+- One-click copy to clipboard
+
 ### Validation
 
 Validate YAML syntax and verify all relationship references:

examples/archsight/generated/archsight-interface.yaml

@@ -53,7 +53,7 @@ metadata:
       - `-> none & <- none` - true orphans with no relations at all
     architecture/openapi: 3.1.0
     architecture/version: '1.0'
-    architecture/status: GA
+    architecture/status: General-Availability
     architecture/visibility: public
     architecture/tags: https,rest
     architecture/encoding: json

examples/archsight/interfaces/interfaces.yaml

@@ -19,7 +19,7 @@ metadata:
       | `import` | Run import handlers to generate resources |
       | `version` | Display the archsight version |
     architecture/version: '1.0'
-    architecture/status: GA
+    architecture/status: General-Availability
     architecture/visibility: public
     architecture/tags: cli,thor,terminal
     architecture/documentation: https://github.com/ionos-cloud/archsight
@@ -79,7 +79,7 @@ metadata:
       http://localhost:6789/sse
       ```
     architecture/version: '1.0'
-    architecture/status: GA
+    architecture/status: General-Availability
     architecture/visibility: public
     architecture/tags: mcp,ai,claude,sse,http
     architecture/documentation: https://modelcontextprotocol.io

lib/archsight/analysis/executor.rb

@@ -79,9 +79,6 @@ def execute_all(filter: nil)
         # Filter by name pattern if provided
         analyses = analyses.select { |a| filter.match?(a.name) } if filter
 
-        # Filter to enabled analyses
-        analyses = analyses.select { |a| analysis_enabled?(a) }
-
         analyses.map { |analysis| execute(analysis) }
       end
 
@@ -100,13 +97,6 @@ def parse_timeout(timeout_str)
 
         DEFAULT_TIMEOUT
       end
-
-      # Check if analysis is enabled
-      # @param analysis [Object] Analysis instance
-      # @return [Boolean] true if enabled
-      def analysis_enabled?(analysis)
-        analysis.annotations["analysis/enabled"] != "false"
-      end
     end
   end
 end

lib/archsight/annotations/annotation.rb

@@ -83,40 +83,9 @@ def validate(value)
     errors = []
     return errors if value.nil?
 
-    # Check enum constraint
-    if @enum
-      values = list? ? value.to_s.split(",").map(&:strip) : [value.to_s]
-      invalid_values = values.reject { |v| @enum.include?(v) }
-      invalid_values.each do |v|
-        errors << "invalid value '#{v}'. Expected one of: #{@enum.join(", ")}"
-      end
-    end
-
-    # Check type constraint
-    if @type.is_a?(Class) && errors.empty?
-      values_to_check = list? ? value.to_s.split(/,|\n/).map(&:strip).reject(&:empty?) : [value.to_s]
-
-      values_to_check.each do |string_value|
-        valid = case @type.to_s
-                when "Integer"
-                  string_value.match?(/\A-?\d+\z/)
-                when "Float"
-                  string_value.match?(/\A-?\d+(\.\d+)?\z/)
-                when "URI"
-                  begin
-                    URI.parse(string_value)
-                    string_value.match?(%r{\Ahttps?://})
-                  rescue URI::InvalidURIError
-                    false
-                  end
-                when "Archsight::Annotations::EmailRecipient"
-                  Archsight::Annotations::EmailRecipient.valid?(string_value)
-                else
-                  true
-                end
-        errors << "invalid value '#{string_value}'. #{type_error_message}" unless valid
-      end
-    end
+    validate_enum(value, errors)
+    validate_type(value, errors) if errors.empty?
+    validate_code(value, errors) if errors.empty?
 
     errors
   end
@@ -130,6 +99,14 @@ def markdown?
     @format == :markdown
   end
 
+  def code?
+    @format == :ruby
+  end
+
+  def code_language
+    @format if code?
+  end
+
   # Example value for templates
   def example_value
     if @enum
@@ -155,6 +132,49 @@ def type_error_message
     end
   end
 
+  def validate_enum(value, errors)
+    return unless @enum
+
+    values = list? ? value.to_s.split(",").map(&:strip) : [value.to_s]
+    invalid_values = values.reject { |v| @enum.include?(v) }
+    invalid_values.each do |v|
+      errors << "invalid value '#{v}'. Expected one of: #{@enum.join(", ")}"
+    end
+  end
+
+  def validate_type(value, errors)
+    return unless @type.is_a?(Class)
+
+    values_to_check = list? ? value.to_s.split(/,|\n/).map(&:strip).reject(&:empty?) : [value.to_s]
+    values_to_check.each do |string_value|
+      errors << "invalid value '#{string_value}'. #{type_error_message}" unless valid_type_value?(string_value)
+    end
+  end
+
+  def valid_type_value?(string_value)
+    case @type.to_s
+    when "Integer" then string_value.match?(/\A-?\d+\z/)
+    when "Float" then string_value.match?(/\A-?\d+(\.\d+)?\z/)
+    when "URI" then valid_uri?(string_value)
+    when "Archsight::Annotations::EmailRecipient" then Archsight::Annotations::EmailRecipient.valid?(string_value)
+    else true
+    end
+  end
+
+  def valid_uri?(string_value)
+    URI.parse(string_value)
+    string_value.match?(%r{\Ahttps?://})
+  rescue URI::InvalidURIError
+    false
+  end
+
+  def validate_code(value, errors)
+    return unless code? && !value.to_s.strip.empty?
+
+    syntax_error = validate_code_syntax(value.to_s)
+    errors << syntax_error if syntax_error
+  end
+
   def derive_format
     case @filter
     when :word then :tag_word
@@ -165,4 +185,28 @@ def derive_format
   def build_regex
     Regexp.new("^#{Regexp.escape(key).gsub('\*', ".+")}$")
   end
+
+  # Validate code syntax based on format
+  # @param code [String] The code to validate
+  # @return [String, nil] Error message or nil if valid
+  def validate_code_syntax(code)
+    case @format
+    when :ruby
+      validate_ruby_syntax(code)
+    end
+  end
+
+  # Validate Ruby syntax using RubyVM
+  # @param code [String] Ruby code to validate
+  # @return [String, nil] Error message or nil if valid
+  def validate_ruby_syntax(code)
+    # steep:ignore:start
+    RubyVM::InstructionSequence.compile(code)
+    # steep:ignore:end
+    nil
+  rescue SyntaxError => e
+    # Extract just the error message without the full backtrace
+    message = e.message.lines.first&.strip || "Syntax error"
+    "Ruby syntax error: #{message}"
+  end
 end

lib/archsight/annotations/architecture_annotations.rb

@@ -9,12 +9,8 @@ def self.included(base)
       annotation "architecture/abbr",
                  description: "Abbreviation or short name",
                  title: "Abbreviation"
-      annotation "architecture/evidence",
-                 description: "Supporting evidence or notes",
-                 title: "Evidence",
-                 format: :markdown
       annotation "architecture/description",
-                 description: "Textual description of the interface",
+                 description: "Textual description of the resource",
                  title: "Description",
                  format: :markdown
       annotation "architecture/documentation",
@@ -25,35 +21,6 @@ def self.included(base)
                  description: "Comma-separated tags",
                  filter: :list,
                  title: "Tags"
-      annotation "architecture/encoding",
-                 description: "Data encoding format",
-                 filter: :list,
-                 title: "Encoding"
-      annotation "architecture/title",
-                 description: "Interface title",
-                 title: "Title"
-      annotation "architecture/openapi",
-                 description: "OpenAPI specification version",
-                 filter: :word,
-                 title: "OpenAPI"
-      annotation "architecture/version",
-                 description: "API or interface version",
-                 filter: :word,
-                 title: "Version",
-                 sidebar: false
-      annotation "architecture/status",
-                 description: "Lifecycle status (General-Availability, Early-Access, Development)",
-                 filter: :word,
-                 title: "Status"
-      annotation "architecture/visibility",
-                 description: "API visibility (public, private, internal)",
-                 filter: :word,
-                 enum: %w[public private internal],
-                 title: "Visibility"
-      annotation "architecture/applicationSets",
-                 description: "Related ArgoCD ApplicationSets",
-                 title: "ApplicationSets",
-                 format: :markdown
     end
   end
 end

lib/archsight/annotations/interface_annotations.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Interface module adds interface-specific annotations to resource classes
+module Archsight::Annotations::Interface
+  def self.included(base)
+    base.class_eval do
+      annotation "architecture/encoding",
+                 description: "Data encoding format",
+                 filter: :list,
+                 title: "Encoding"
+      annotation "architecture/title",
+                 description: "Interface title",
+                 title: "Title"
+      annotation "architecture/openapi",
+                 description: "OpenAPI specification version",
+                 filter: :word,
+                 title: "OpenAPI"
+      annotation "architecture/version",
+                 description: "API or interface version",
+                 filter: :word,
+                 title: "Version",
+                 sidebar: false
+      annotation "architecture/status",
+                 description: "Lifecycle status",
+                 filter: :word,
+                 enum: %w[General-Availability Early-Access Development],
+                 title: "Status"
+      annotation "architecture/visibility",
+                 description: "API visibility (public, private, internal)",
+                 filter: :word,
+                 enum: %w[public private internal],
+                 title: "Visibility"
+    end
+  end
+end

lib/archsight/cli.rb

@@ -191,7 +191,7 @@ def load_database_for_analysis
     def filter_analyses(db)
       analyses = db.instances_by_kind("Analysis").values
       analyses = analyses.select { |a| Regexp.new(options[:filter], Regexp::IGNORECASE).match?(a.name) } if options[:filter]
-      analyses.reject { |a| a.annotations["analysis/enabled"] == "false" }
+      analyses
     end
 
     def print_analysis_dry_run(analyses)