archsight 0.1.0

data/lib/archsight/resources/technology_interface.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# TechnologyInterface is the backing of an applicationInterface
+class Archsight::Resources::TechnologyInterface < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents a point of access where technology services are made available.
+
+    ## ArchiMate Definition
+
+    **Layer:** Technology
+    **Aspect:** Active Structure (external)
+
+    A technology interface represents a point of access where technology services offered
+    by a node can be accessed. It provides the technical implementation backing for
+    application interfaces.
+
+    ## Usage
+
+    Use TechnologyInterface to represent:
+
+    - Network endpoints (IP:port combinations)
+    - Protocol bindings (HTTP, gRPC, AMQP)
+    - Load balancer virtual IPs
+    - Service mesh endpoints
+    - DNS entries
+  MD
+
+  icon "data-transfer-both"
+  layer "technology"
+
+  relation :suppliedBy, :technologyComponents, :TechnologyService
+end

data/lib/archsight/resources/technology_node.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# TechnologyNode represents physical infrastructure (VMs, servers, Kubernetes nodes)
+class Archsight::Resources::TechnologyNode < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents physical infrastructure hosting application components.
+
+    ## ArchiMate Definition
+
+    **Layer:** Technology
+    **Aspect:** Active Structure
+
+    A node represents a computational or physical resource that hosts, manipulates, or
+    interacts with other computational or physical resources. In cloud contexts, this
+    includes compute instances, storage systems, and network equipment.
+
+    ## Usage
+
+    Use TechnologyNode to represent:
+
+    - Virtual machines
+    - Bare metal servers
+    - Kubernetes nodes
+    - Network appliances
+    - Storage arrays
+  MD
+
+  icon "server-connection"
+  layer "technology"
+
+  annotation "infrastructure/type",
+             description: "Type of infrastructure node",
+             title: "Infrastructure Type",
+             enum: %w[vm bare-metal kubernetes-node network-appliance storage-array],
+             list: true
+
+  relation :realizes, :businessConstraints, :BusinessConstraint
+  relation :servedBy, :technologyServices, :TechnologyService
+  relation :servedBy, :businessActors, :BusinessActor
+end

data/lib/archsight/resources/technology_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# TechnologyService supports the deployment of the application on a high level
+class Archsight::Resources::TechnologyService < Archsight::Resources::Base
+  include_annotations :git, :architecture, :generated
+
+  description <<~MD
+    Represents an explicitly defined piece of technology functionality.
+
+    ## ArchiMate Definition
+
+    **Layer:** Technology
+    **Aspect:** Behavior
+
+    A technology service represents an explicitly defined piece of functionality exposed
+    by technology nodes. It provides platform-level capabilities that support the deployment
+    and operation of application components.
+
+    ## Usage
+
+    Use TechnologyService to represent:
+
+    - Cloud platform services (AWS EC2, Azure VMs)
+    - Container orchestration services
+    - Managed database services
+    - CI/CD pipeline services
+    - Monitoring and logging platforms
+  MD
+
+  icon "cloud"
+  layer "technology"
+
+  relation :suppliedBy, :technologyComponents, :TechnologySystemSoftware
+  relation :servedBy, :businessActors, :BusinessActor
+end

data/lib/archsight/resources/technology_system_software.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# TechnologySystemSoftware serves the TechnologySystemSoftware
+class Archsight::Resources::TechnologySystemSoftware < Archsight::Resources::Base
+  include_annotations :git, :architecture
+
+  description <<~MD
+    Represents a logical infrastructure component that serves application components.
+
+    ## ArchiMate Definition
+
+    **Layer:** Technology
+    **Aspect:** Active Structure
+
+    System software represents software that provides or contributes to an environment
+    for storing, executing, and using software or data deployed within it. Logical
+    technology components represent abstract infrastructure units.
+
+    ## Usage
+
+    Use TechnologySystemSoftware to represent:
+
+    - Database clusters
+    - Message broker clusters
+    - Cache clusters
+    - Load balancers
+    - Service meshes
+  MD
+
+  icon "terminal-tag"
+  layer "technology"
+
+  relation :realizedBy, :technologyComponents, :TechnologyNode
+  relation :realizedThrough, :technologyArtifacts, :TechnologyArtifact
+  relation :exposes, :applicationInterfaces, :ApplicationInterface
+  relation :dependsOn, :applicationInterfaces, :ApplicationInterface
+end

data/lib/archsight/resources/view.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# View represents a saved query with custom table display options
+class Archsight::Resources::View < Archsight::Resources::Base
+  include_annotations :architecture
+
+  description <<~MD
+    Represents a saved query with customizable display options.
+
+    ## Definition
+
+    A View is a tool-specific resource type that saves a query and its display configuration.
+    Views allow users to create reusable perspectives on the architecture data, with custom
+    column selections and sorting options.
+
+    ## Usage
+
+    Use View to create:
+
+    - Compliance dashboards
+    - Team-specific resource lists
+    - Audit views
+    - Custom reports
+    - Filtered resource tables
+  MD
+
+  icon "view-grid"
+  layer "other"
+
+  annotation "view/query",
+             description: 'Query string to execute (e.g., "ApplicationService: backup/mode == \"none\"")',
+             title: "Query",
+             sidebar: false
+
+  annotation "view/fields",
+             description: "Comma-separated list of annotation fields or @components to display as columns. " \
+                          "Components: @activity, @git, @jira, @languages, @owner, @repositories, @status",
+             title: "Display Fields",
+             sidebar: false
+
+  annotation "view/type",
+             description: "Display type for results",
+             title: "Display Type",
+             enum: %w[list:name list:name+kind],
+             sidebar: false
+
+  annotation "view/sort",
+             description: 'Comma-separated list of fields to sort by. Prefix with - for descending (e.g., "-scc/language/Go/loc,name"). Special fields: name, kind',
+             title: "Sort Fields",
+             sidebar: false
+end

data/lib/archsight/resources.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Archsight
+  # Resources contains all resources to reflect the architecture assets
+  module Resources
+    # Store the class mapping
+    @resource_classes = {}
+
+    # Register a resource class
+    def self.register(klass)
+      # Skip anonymous classes (used in tests)
+      return if klass.name.nil?
+
+      name = klass.name.split("::").last
+      @resource_classes[name] = klass
+    end
+
+    # Returns all registered resource classes
+    def self.resource_classes
+      @resource_classes
+    end
+
+    # Returns the class by name
+    def self.[](klass_name)
+      @resource_classes[klass_name.to_s]
+    end
+
+    # Iterate over all resource class names (sorted)
+    def self.each(&)
+      @resource_classes.keys.sort.each(&)
+    end
+
+    # Get the constant by name (for backward compatibility with const_get)
+    def self.const_get(name)
+      @resource_classes[name.to_s] || super
+    end
+  end
+end
+
+# Load dependencies after module is defined
+require_relative "helpers"
+
+# Define the Annotations namespace before loading annotation files
+# (required for compact class definitions like Archsight::Annotations::Annotation)
+module Archsight::Annotations; end
+
+Dir[File.join(__dir__, "annotations", "*.rb")].each { |file| require_relative file }
+require_relative "resources/base"
+Dir[File.join(__dir__, "resources", "*.rb")].each { |file| require_relative file }

data/lib/archsight/template.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "resources"
+
+module Archsight
+  # Template generates YAML templates for architecture resources
+  class Template
+    def self.generate(kind_name)
+      klass = Archsight::Resources[kind_name.to_s]
+      raise "Unknown resource kind '#{kind_name}'" unless klass
+
+      yaml = {}
+      yaml["apiVersion"] = "architecture/v1alpha1"
+      yaml["kind"] = kind_name
+      yaml["metadata"] = {
+        "name" => "TODO"
+      }
+
+      add_annotations(yaml, klass)
+      add_relations(yaml, klass)
+
+      yaml.to_yaml
+    end
+
+    class << self
+      private
+
+      def add_annotations(yaml, klass)
+        non_pattern_annotations = klass.annotations.reject(&:pattern?)
+        return if non_pattern_annotations.empty?
+
+        annotations = non_pattern_annotations.to_h { |a| [a.key, a.example_value] }
+        yaml["metadata"]["annotations"] = annotations unless annotations.empty?
+      end
+
+      def add_relations(yaml, klass)
+        return if klass.relations.empty?
+
+        yaml["spec"] = {} if yaml["spec"].nil?
+        klass.relations.each do |verb, relation_kind, _relation_klass|
+          relation_verb = verb.to_s.delete_prefix(":")
+          yaml["spec"][relation_verb] ||= {}
+          yaml["spec"][relation_verb][relation_kind.to_s] = []
+        end
+      end
+    end
+  end
+end

data/lib/archsight/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Archsight
+  VERSION = "0.1.0"
+end

data/lib/archsight/web/application.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+require "kramdown"
+require "haml"
+require "erb"
+require "fast_mcp"
+
+require_relative "../database"
+require_relative "../graph"
+require_relative "../renderer"
+require_relative "../helpers"
+require_relative "../documentation"
+require_relative "../query"
+require_relative "../resources"
+require_relative "../mcp"
+
+# Define the Web namespace before the class definition
+module Archsight::Web; end
+
+class Archsight::Web::Application < Sinatra::Base
+  class << self
+    attr_accessor :db
+
+    def database
+      @database ||= Archsight::Database.new(Archsight.resources_dir).tap(&:reload!)
+    end
+
+    def reload!
+      start = Time.new
+      puts "== Reloading ..." if database.verbose
+      database.reload!
+      dur = (Time.new - start) * 1000
+      puts format("== done %0.2f ms", dur) if database.verbose
+    end
+  end
+
+  configure do
+    set :views, File.join(__dir__, "views")
+    set :public_folder, File.join(__dir__, "public")
+    set :haml, format: :html5
+    set :server, :puma
+  end
+
+  # MCP Server setup
+  def self.setup_mcp!
+    mcp_server = FastMcp::Server.new(
+      name: "Archsight MCP",
+      version: Archsight::VERSION
+    )
+
+    # Configure MCP tools with database
+    Archsight::MCP.db = database
+
+    mcp_server.register_tool(Archsight::MCP::QueryTool)
+    mcp_server.register_tool(Archsight::MCP::AnalyzeResourceTool)
+    mcp_server.register_tool(Archsight::MCP::ResourceDocTool)
+
+    use FastMcp::Transports::RackTransport, mcp_server, path_prefix: "/mcp"
+  end
+
+  helpers Archsight::GraphvisHelper, Archsight::GraphvisRenderer, Archsight::Helpers
+
+  helpers do
+    def db
+      Archsight::Web::Application.database
+    end
+
+    # Render markdown to HTML with optional URL resolution for repository content
+    # @param data [String] Markdown content
+    # @param git_url [String, nil] Git URL for resolving relative paths (e.g., for README images)
+    def markdown(data, git_url: nil)
+      html = Kramdown::Document.new(data, input: "GFM").to_html
+
+      # Resolve relative URLs if we have a git URL (for repository READMEs)
+      if git_url && (base_url = github_raw_base_url(git_url))
+        html = resolve_relative_urls(html, base_url)
+      end
+
+      # Auto-link bare URLs that aren't already inside HTML attributes or anchor tags
+      html = html.gsub(%r{(?<!=["'])(?<!">)(https?://[^\s<>"]+)}) do |match|
+        # Strip trailing punctuation that's likely sentence-ending, not part of URL
+        url = match.sub(/[.,;:!)]+$/, "")
+        trailing = match[url.length..]
+        %(<a href="#{url}">#{url}</a>#{trailing})
+      end
+      # Convert [[ResourceName]] wiki-style links to resource links
+      html.gsub(/\[\[([^\]]+)\]\]/) do |_match|
+        name = ::Regexp.last_match(1)
+        resource = db.query("name =~ \"#{name}\"").first
+        if resource
+          %(<a href="/kinds/#{resource.kind}/instances/#{resource.name}">#{name}</a>)
+        else
+          %(<span class="broken-link" title="Resource not found">#{name}</span>)
+        end
+      end
+    end
+
+    def to_dollar(num)
+      # Round to 2 decimals first (important for floating‑point edge cases)
+      rounded = (num * 100).round / 100.0
+      # Insert commas every three digits left of the decimal point
+      parts = format("%.2f", rounded).split(".")
+      parts[0] = parts[0].reverse.scan(/\d{1,3}/).join(",").reverse
+      "$#{parts.join(".")}"
+    end
+
+    def http_git(repo_url)
+      repo_url.gsub(/.git$/, "")
+              .gsub(":", "/")
+              .gsub("git@", "https://")
+    end
+
+    def number_with_delimiter(num)
+      num.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+    end
+
+    # Generate asset path with cache-busting query string based on file mtime
+    def asset_path(path)
+      file_path = File.join(settings.public_folder, path)
+      if File.exist?(file_path)
+        mtime = File.mtime(file_path).to_i
+        "#{path}?v=#{mtime}"
+      else
+        path
+      end
+    end
+
+    # Convert timestamp to human-readable relative time
+    def time_ago(timestamp)
+      return nil unless timestamp
+
+      time = timestamp.is_a?(Time) ? timestamp : Time.parse(timestamp.to_s)
+      seconds = (Time.now - time).to_i
+
+      units = [
+        [60, "second"],
+        [60, "minute"],
+        [24, "hour"],
+        [7, "day"],
+        [4, "week"],
+        [12, "month"],
+        [Float::INFINITY, "year"]
+      ]
+
+      value = seconds
+      units.each do |divisor, unit|
+        return "just now" if unit == "second" && value < 10
+        return "#{value} #{unit}#{"s" if value != 1} ago" if value < divisor
+
+        value /= divisor
+      end
+    end
+  end
+
+  get "/" do
+    haml :index
+  end
+
+  get "/reload" do
+    Archsight::Web::Application.reload!
+    if 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>"
+    else
+      haml :index
+    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
+  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"]}\""
+  end
+
+  # GET /search - for direct URL access, bookmarks, and browser history
+  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)
+  end
+
+  get "/dot" do
+    content_type "text/plain"
+    create_graph_all(db, :draw_dot)
+  end
+
+  get "/kinds/:kind" do
+    @kind = params["kind"]
+    haml :index
+  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)
+  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
+end