archsight 0.2.4 → 0.2.6

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "grapher"
+require_relative "../registry"
+
+# ElixirGrapher — analyses an Elixir repository and generates a GraphViz DOT
+# graph of its application/package structure, stored as
+# architecture/elixir/modules on the TechnologyArtifact.
+#
+# Supports single-app projects (mix.exs at root) and umbrella projects
+# (apps/*/mix.exs). Uses pure static regex analysis of alias/import/use
+# statements — no Elixir toolchain required.
+#
+# Configuration:
+#   import/config/path     - Path to the Elixir repository root
+#   import/config/ranksep  - Horizontal gap between rank columns (default: 0.6)
+#   import/config/nodesep  - Vertical gap between nodes in a column (default: 0.15)
+class Archsight::Import::Handlers::ElixirGrapher < Archsight::Import::Handlers::Grapher
+  def self.language_name = "elixir"
+
+  def self.applicable?(path)
+    File.exist?(File.join(path, "mix.exs")) ||
+      Dir.glob(File.join(path, "apps/*/mix.exs")).any?
+  end
+
+  def wrap_single_module?
+    true
+  end
+
+  SKIP_DIRS = %w[_build deps test tests .git cover priv node_modules _checkouts config].freeze
+
+  # MAX_PKG_DEPTH = 3 allows my_app/web/controllers depth, which is common in Phoenix apps.
+  MAX_PKG_DEPTH = 3
+
+  ALIAS_RE  = /^\s*alias\s+(\w+(?:\.\w+)*(?:\.\{[^}]*\})?)/
+  IMPORT_RE = /^\s*import\s+([\w.]+)/
+  USE_RE    = /^\s*use\s+([\w.]+)/
+
+  private
+
+  # ── Module discovery ─────────────────────────────────────────────────────
+
+  def discover_modules(repo_root)
+    return umbrella_modules(repo_root) if umbrella?(repo_root)
+
+    lib = File.join(repo_root, "lib")
+    dirs = lib_all_top_dirs(lib)
+
+    if dirs.empty?
+      # No lib sub-dirs: single flat app
+      app_name = parse_app_name(File.join(repo_root, "mix.exs")) || File.basename(repo_root)
+      return [[".", app_name]]
+    end
+
+    # One namespace dir (common case): use it as the single module.
+    # Multiple dirs (e.g. Phoenix: ic_daily + ic_daily_web + mix): each becomes its own cluster.
+    # rel_dir "lib/<ns>" lets collect_packages scope scans and pkg_module_dir assign correctly.
+    dirs.map { |d| ["lib/#{d}", d] }
+  end
+
+  def umbrella?(repo_root)
+    content = begin
+      File.read(File.join(repo_root, "mix.exs"), encoding: "utf-8")
+    rescue StandardError
+      ""
+    end
+    content.match?(/\bapps_path\s*:/) || Dir.glob(File.join(repo_root, "apps/*/mix.exs")).any?
+  end
+
+  def umbrella_modules(repo_root)
+    Dir.glob(File.join(repo_root, "apps/*/mix.exs")).filter_map do |mixexs|
+      app_dir = File.dirname(mixexs)
+      rel_dir = app_dir.delete_prefix("#{repo_root}/")
+      mod_name = parse_app_name(mixexs) || File.basename(app_dir)
+      [rel_dir, mod_name]
+    end
+  end
+
+  def parse_app_name(mixexs_path)
+    content = File.read(mixexs_path, encoding: "utf-8")
+    content.match(/\bapp:\s*:(\w+)/)[1]
+  rescue StandardError
+    nil
+  end
+
+  def lib_all_top_dirs(lib_dir)
+    return [] unless Dir.exist?(lib_dir)
+
+    Dir.children(lib_dir).select { |e| File.directory?(File.join(lib_dir, e)) }.sort
+  end
+
+  # ── Package collection ────────────────────────────────────────────────────
+
+  def collect_packages(repo_root, modules, _prefix)
+    known_prefixes = modules.map { |_, mod_name| mod_name }
+    all_pkgs = {}
+
+    modules.each do |rel_dir, mod_name|
+      mod_dir = rel_dir == "." ? repo_root : File.join(repo_root, rel_dir)
+      lib_dir = Dir.exist?(File.join(mod_dir, "lib")) ? File.join(mod_dir, "lib") : mod_dir
+
+      scan_lib_dir(lib_dir, mod_name, known_prefixes, all_pkgs)
+    end
+
+    # Drop deps that don't correspond to any scanned package: this removes references to
+    # framework modules whose namespace collides with an application namespace (e.g.
+    # Mix.Task from the stdlib when the app also has a lib/mix/ directory).
+    pkg_set = all_pkgs.keys.to_set
+    all_pkgs.each_value { |deps| deps.select! { |d| pkg_set.include?(d) } }
+
+    all_pkgs
+  end
+
+  def scan_lib_dir(lib_dir, mod_name, known_prefixes, all_pkgs)
+    safe_glob(File.join(lib_dir, "**", "*.ex")).each do |ex_file|
+      rel_parts = ex_file.delete_prefix("#{lib_dir}/").split("/")
+      next if rel_parts.any? { |p| SKIP_DIRS.include?(p) }
+
+      pkg = cap_depth(file_to_pkg(ex_file, lib_dir, mod_name), mod_name)
+      all_pkgs[pkg] ||= []
+
+      extract_deps(ex_file, known_prefixes).each do |dep|
+        dep = cap_depth(dep, mod_name)
+        next if dep == pkg || all_pkgs[pkg].include?(dep)
+
+        all_pkgs[pkg] << dep
+      end
+    end
+  end
+
+  # ── Import extraction ─────────────────────────────────────────────────────
+
+  def extract_deps(ex_file, known_prefixes)
+    content = File.read(ex_file, encoding: "utf-8")
+    raw_modules = []
+
+    content.each_line do |line|
+      line.scan(ALIAS_RE)  { |(m)| raw_modules.concat(expand_alias(m)) }
+      line.scan(IMPORT_RE) { |(m)| raw_modules << m }
+      line.scan(USE_RE)    { |(m)| raw_modules << m }
+    end
+
+    raw_modules.filter_map { |m| resolve_dep(m, known_prefixes) }.uniq
+  rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+    []
+  end
+
+  # Expand multi-alias: MyApp.Web.{Router, Controller} → [MyApp.Web.Router, MyApp.Web.Controller]
+  def expand_alias(raw)
+    m = raw.match(/\A([\w.]+)\.\{([^}]+)\}/)
+    unless m
+      # Strip ", as: Alias" suffix if present
+      return [raw.split(",").first.strip]
+    end
+
+    prefix = m[1]
+    m[2].split(",").map { |n| "#{prefix}.#{n.strip}" }
+  end
+
+  def resolve_dep(mod_str, known_prefixes)
+    path = module_to_path(mod_str)
+    return nil unless known_prefixes.any? { |pfx| path == pfx || path.start_with?("#{pfx}/") }
+
+    path
+  end
+
+  # CamelCase Elixir module name → snake_case/slash path
+  # MyApp.Web.Controller → my_app/web/controller
+  def module_to_path(mod_name)
+    mod_name.split(".").map do |part|
+      part.gsub(/(?<=[a-z0-9])([A-Z])/, '_\1').downcase
+    end.join("/")
+  end
+
+  # ── Package path helpers ──────────────────────────────────────────────────
+
+  # Maps a file to a package path. Prepends mod_name when lib_dir is the namespace dir
+  # itself (rel_dir = "lib/<ns>") so that accounts.ex → my_app/accounts, not just accounts.
+  # When lib_dir is the parent lib/ directory (rel_dir = "."), the rel path already carries
+  # the namespace prefix and is returned as-is.
+  def file_to_pkg(abs_path, lib_dir, mod_name)
+    rel = abs_path.delete_prefix("#{lib_dir}/").delete_suffix(File.extname(abs_path))
+    return mod_name if rel == mod_name
+    return rel if rel.start_with?("#{mod_name}/")
+
+    "#{mod_name}/#{rel}"
+  end
+
+  def cap_depth(pkg, mod_name)
+    return pkg if pkg != mod_name && !pkg.start_with?("#{mod_name}/")
+
+    suffix = pkg.delete_prefix("#{mod_name}/")
+    return mod_name if suffix == pkg
+
+    parts = suffix.split("/")
+    return pkg if parts.length <= MAX_PKG_DEPTH - 1
+
+    "#{mod_name}/#{parts.first(MAX_PKG_DEPTH - 1).join("/")}"
+  end
+end
+
+Archsight::Import::Registry.register("elixir-grapher", Archsight::Import::Handlers::ElixirGrapher)

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../handler"
+require_relative "go_module_parser"
+require_relative "../registry"
+
+# GoDepResolver handler - second-pass resolver that patches dependsOn relations
+# onto ApplicationComponents generated by GoGrapher.
+#
+# Runs after all GoGraphers complete (iteration 2 of the executor loop) so the
+# database contains the full set of freshly-generated ApplicationComponents.
+# Output goes to a single shared generated/relationships.yaml file (all repos
+# combined), loaded after modules.yaml alphabetically so its version of each
+# component — with dependsOn — takes precedence.
+#
+# One Import:GoDepResolver:* resource is emitted by each GoGrapher run; this
+# handler is registered as a child of GoGrapher via the generates relation so
+# the executor knows to wait until GoGrapher has completed.
+#
+# Configuration:
+#   import/config/path - Path to the Go repository root (same as GoGrapher)
+class Archsight::Import::Handlers::GoDepResolver < Archsight::Import::Handler
+  include Archsight::Import::Handlers::GoModuleParser
+
+  def execute
+    @path = config("path")
+    raise "Missing required config: path" unless @path
+    raise "Directory not found: #{@path}" unless File.directory?(@path)
+
+    import_resource.annotations["import/outputPath"] ||= "generated/relationships.yaml"
+
+    modules = discover_modules(@path)
+    return write_yaml(YAML.dump(self_marker)) if modules.empty?
+
+    existing_components = database&.instances_by_kind("ApplicationComponent") || {}
+    output = +""
+
+    modules.each do |rel_dir, mod_name|
+      mod_dir = rel_dir == "." ? @path : File.join(@path, rel_dir)
+      dep_names = compute_deps(mod_dir, mod_name, existing_components)
+      next if dep_names.empty?
+
+      comp_name = component_name(mod_name)
+      existing = existing_components[comp_name]
+      next unless existing
+
+      # Rebuild the full ApplicationComponent merging dependsOn into the existing
+      # spec (which carries realizedThrough, exposes, etc. from GoGrapher).
+      spec = existing.raw.fetch("spec", {}).dup
+      spec["dependsOn"] = { "applicationComponents" => dep_names }
+
+      component = {
+        "apiVersion" => "architecture/v1alpha1",
+        "kind" => "ApplicationComponent",
+        "metadata" => {
+          "name" => comp_name,
+          "annotations" => existing.annotations.merge(
+            "generated/script" => import_resource.name,
+            "generated/at" => Time.now.utc.iso8601
+          )
+        },
+        "spec" => spec
+      }
+      output << YAML.dump(component)
+    end
+
+    write_yaml(output + YAML.dump(self_marker))
+  end
+
+  private
+
+  def compute_deps(mod_dir, mod_name, existing_components)
+    prefix = same_origin_prefix(mod_name)
+    return [] unless prefix
+
+    go_mod_requires(mod_dir)
+      .select { |r| r.start_with?(prefix) && r != mod_name }
+      .filter_map { |r| component_name(r) if existing_components.key?(component_name(r)) }
+      .sort.uniq
+  end
+end
+
+Archsight::Import::Registry.register("go-dep-resolver", Archsight::Import::Handlers::GoDepResolver)

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

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require_relative "grapher"
+require_relative "go_module_parser"
+require_relative "../registry"
+
+# GoGrapher handler - analyses a Go repository and generates a GraphViz DOT
+# graph of its module/package structure, stored as architecture/go/modules on
+# the TechnologyArtifact so it can be rendered in the frontend.
+#
+# Also emits one ApplicationComponent per go.mod module, linked to the repo
+# artifact via realizedThrough. If OpenAPI spec files are found in a module
+# directory, the component gains an exposes relation to the matching interface.
+#
+# dependsOn relations between components are resolved in a second pass by the
+# GoDepResolver handler, which runs after all graphers have seeded the database.
+#
+# Configuration:
+#   import/config/path                 - Path to the Go repository root (go.mod or go.work)
+#   import/config/ranksep              - Horizontal gap between rank columns (default: 0.6)
+#   import/config/nodesep              - Vertical gap between nodes in a column (default: 0.15)
+#   import/config/interface_visibility - Visibility prefix for detected interfaces (default: Private)
+class Archsight::Import::Handlers::GoGrapher < Archsight::Import::Handlers::Grapher
+  include Archsight::Import::Handlers::GoModuleParser
+
+  OPENAPI_FILENAMES = %w[openapi.yaml openapi.yml openapi.json swagger.yaml swagger.yml swagger.json].freeze
+  OPENAPI_SUBDIRS   = %w[api docs spec].freeze
+
+  def self.language_name = "go"
+
+  def self.applicable?(path)
+    File.exist?(File.join(path, "go.work")) ||
+      File.exist?(File.join(path, "go.mod")) ||
+      Dir.glob(File.join(path, "**/go.mod")).any?
+  rescue Errno::ELOOP, Errno::ENOTDIR
+    false
+  end
+
+  private
+
+  def show_root_package_node?
+    true
+  end
+
+  def suppress_edge_to?(dep, pkg_set, has_children)
+    has_children.include?(dep) && !pkg_set.include?(dep)
+  end
+
+  # ── Application resources ─────────────────────────────────────────────────
+
+  def additional_resources(path, modules, artifact_name)
+    visibility = config("interface_visibility", default: "Private")
+    output = +""
+
+    modules.each do |rel_dir, mod_name|
+      mod_dir = rel_dir == "." ? path : File.join(path, rel_dir)
+      specs = detect_openapi_specs(mod_dir)
+      existing_interfaces = database&.instances_by_kind("ApplicationInterface") || {}
+      interface_names = specs.filter_map { |s| interface_name_from_spec(s, visibility: visibility) }
+                             .select { |n| existing_interfaces.key?(n) }
+
+      comp_spec = { "realizedThrough" => { "technologyArtifacts" => [artifact_name] } }
+      comp_spec["exposes"] = { "applicationInterfaces" => interface_names } if interface_names.any?
+
+      # Build directly without resource_yaml so the component is not tracked in
+      # the generates spec — ApplicationComponents are seed resources the user
+      # is expected to keep and refine, not auto-regenerated on each run.
+      component = untracked_resource_yaml(
+        kind: "ApplicationComponent",
+        name: component_name(mod_name),
+        spec: comp_spec
+      )
+      output << YAML.dump(component)
+    end
+
+    # Emit a GoDepResolver import so dependsOn relations can be resolved in a
+    # second pass, after all graphers have run and the database has been reloaded
+    # with the full set of ApplicationComponents.
+    resolver_name = "Import:GoDepResolver:#{artifact_name.delete_prefix("Repo:")}"
+    output << YAML.dump(import_yaml(
+                          name: resolver_name,
+                          handler: "go-dep-resolver",
+                          config: { "path" => path }
+                        ))
+
+    output
+  end
+
+  # ── Package collection ────────────────────────────────────────────────────
+
+  def collect_packages(repo_root, modules, _prefix)
+    workspace_mode = File.exist?(File.join(repo_root, "go.work"))
+    mod_names = modules.map { |_, mod_name| mod_name }
+    all_pkgs = {}
+
+    modules.map(&:first).each do |rel_dir|
+      mod_dir = rel_dir == "." ? repo_root : File.join(repo_root, rel_dir)
+      cmd = ["go", "list", "-e", "-f", "{{.ImportPath}}|||{{join .Imports \" \"}}", "./..."]
+      cmd.insert(2, "-mod=vendor") if File.directory?(File.join(mod_dir, "vendor"))
+      cmd.insert(2, "-mod=readonly") unless workspace_mode || cmd.include?("-mod=vendor")
+      out, err, status = Open3.capture3(*cmd, chdir: mod_dir)
+
+      unless status.success?
+        progress.warn("Skipping #{rel_dir}: #{err.lines.first.to_s.strip}")
+        next
+      end
+
+      out.each_line do |line|
+        next unless line.include?("|||")
+
+        pkg, _, imports_str = line.partition("|||")
+        pkg = pkg.strip
+        next if pkg.include?("testdata") || pkg.start_with?("_")
+        next unless mod_names.any? { |m| pkg == m || pkg.start_with?("#{m}/") }
+
+        internal_imports = imports_str.split.reject { |i| i.include?("testdata") }.select do |i|
+          mod_names.any? { |m| i == m || i.start_with?("#{m}/") }
+        end
+        all_pkgs[pkg] = internal_imports
+      end
+    end
+
+    all_pkgs
+  end
+
+  # ── OpenAPI detection ─────────────────────────────────────────────────────
+
+  def untracked_resource_yaml(kind:, name:, spec: {})
+    {
+      "apiVersion" => "architecture/v1alpha1",
+      "kind" => kind,
+      "metadata" => {
+        "name" => name,
+        "annotations" => {
+          "generated/script" => import_resource.name,
+          "generated/at" => Time.now.utc.iso8601
+        }
+      },
+      "spec" => spec
+    }
+  end
+
+  def detect_openapi_specs(mod_dir)
+    candidates = OPENAPI_FILENAMES.map { |f| File.join(mod_dir, f) }
+    OPENAPI_SUBDIRS.each do |sub|
+      OPENAPI_FILENAMES.each { |f| candidates << File.join(mod_dir, sub, f) }
+    end
+
+    candidates.filter_map do |path|
+      next unless File.file?(path)
+
+      begin
+        content = File.read(path)
+        doc = path.end_with?(".json") ? JSON.parse(content) : YAML.safe_load(content)
+        doc.is_a?(Hash) ? doc : nil
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  def interface_name_from_spec(spec, visibility: "Private")
+    info = spec["info"] || {}
+    title = (info["title"] || "").strip
+    return nil if title.empty?
+
+    version = (info["version"] || "1.0").to_s
+    api_name = title.split(/[\s\-_]/).map(&:capitalize).join
+    version_str = version.split(".").first.to_s.sub(/^v/i, "")
+    vis = visibility.split("-").map(&:capitalize).join
+    "#{vis}:#{api_name}:v#{version_str}:RestAPI"
+  end
+end
+
+Archsight::Import::Registry.register("go-grapher", Archsight::Import::Handlers::GoGrapher)

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "find"
+
+# Shared Go module parsing utilities included by GoGrapher and GoDepResolver.
+#
+# Provides go.mod discovery, module name reading, require parsing, and the
+# component_name convention (strip SCM host, join path segments with ":").
+module Archsight::Import::Handlers::GoModuleParser
+  # Discover all Go modules in a repository root.
+  # Handles go.work workspaces, single-module repos, and multi-module monorepos
+  # (root go.mod plus subdirectory go.mod files without go.work).
+  #
+  # @param repo_root [String] Absolute path to the repository root
+  # @return [Array<Array<String>>] List of [rel_dir, mod_name] pairs
+  def discover_modules(repo_root)
+    work_file = File.join(repo_root, "go.work")
+    modules = []
+
+    if File.exist?(work_file)
+      content = File.read(work_file)
+      dirs = if (block_match = content.match(/\buse\s*\((.*?)\)/m))
+               block_match[1].split.map(&:strip).reject(&:empty?)
+             else
+               content.scan(/\buse\s+(\S+)/).flatten
+             end
+      dirs.each do |d|
+        rel = d == "." ? "" : d.delete_prefix("./")
+        abs_dir = rel.empty? ? repo_root : File.join(repo_root, rel)
+        mod_name = read_module_name(abs_dir)
+        modules << [rel.empty? ? "." : rel, mod_name] if mod_name
+      end
+    else
+      root_mod = read_module_name(repo_root)
+      modules << [".", root_mod] if root_mod
+
+      # Also scan subdirectories for additional go.mod files (multi-module monorepo without go.work)
+      Find.find(repo_root) do |path|
+        bn = File.basename(path)
+        Find.prune if File.directory?(path) && %w[vendor testdata .git node_modules].include?(bn)
+        next unless bn == "go.mod"
+
+        mod_dir = File.dirname(path)
+        next if mod_dir == repo_root # already added above
+
+        rel = mod_dir.delete_prefix("#{repo_root}/")
+        name = read_module_name(mod_dir)
+        modules << [rel, name] if name
+      end
+    end
+
+    modules
+  end
+
+  # Read the module name declared in go.mod.
+  # @return [String, nil] Module path or nil if go.mod absent / no module line
+  def read_module_name(mod_dir)
+    gomod = File.join(mod_dir, "go.mod")
+    return nil unless File.exist?(gomod)
+
+    File.foreach(gomod) do |line|
+      m = line.match(/^\s*module\s+(\S+)/)
+      return m[1] if m
+    end
+    nil
+  end
+
+  # Parse require directives from go.mod, handling both block and single-line forms.
+  # @return [Array<String>] Unique module paths listed in require directives
+  def go_mod_requires(mod_dir)
+    gomod = File.join(mod_dir, "go.mod")
+    return [] unless File.exist?(gomod)
+
+    content = File.read(gomod)
+    paths = []
+
+    # Block form: require ( ... )
+    content.scan(/\brequire\s*\(([^)]*)\)/m) do |block|
+      block[0].each_line do |line|
+        stripped = line.strip.split("//").first&.strip
+        mod_path = stripped&.split&.first
+        paths << mod_path if mod_path && !mod_path.empty?
+      end
+    end
+
+    # Single-line form: require module/path vX.Y.Z (strip block forms first to avoid double-counting)
+    content.gsub(/\brequire\s*\([^)]*\)/m, "").scan(/^\s*require\s+(\S+)/) do |m|
+      paths << m[0]
+    end
+
+    paths.uniq
+  end
+
+  # Return the SCM host+org prefix shared by modules in the same org, e.g. "github.com/ionos-cloud/".
+  # @return [String, nil] Prefix with trailing slash, or nil for single-segment names
+  def same_origin_prefix(mod_name)
+    parts = mod_name.split("/")
+    return nil if parts.length < 2
+
+    "#{parts[0, 2].join("/")}/"
+  end
+
+  # Convert a Go module path to an ApplicationComponent name.
+  # Strips the SCM host segment and joins remaining path segments with ":".
+  # "github.com/ionos-cloud/event-gateway/pkg" → "ionos-cloud:event-gateway:pkg"
+  def component_name(mod_name)
+    parts = mod_name.split("/")
+    parts.shift
+    parts.join(":")
+  end
+end