feat: add cross-service protocol linking (Phase 0-2)

  - Add internal/linkutil/ package (shared helpers)
  - Add internal/servicelink/ package with 7 protocol linkers:
    - GraphQL: SDL/resolver discovery, GRAPHQL_CALLS edges
    - gRPC: .proto parsing, server/client discovery, GRPC_CALLS edges
    - Kafka: producer/consumer discovery, KAFKA_CALLS edges
    - SQS: send/receive discovery, SQS_CALLS edges
    - SNS: publish/subscribe discovery, SNS_CALLS edges
    - Pub/Sub: GCP publisher/subscriber, PUBSUB_CALLS edges
    - HTTP: stub for future httplink migration
  - Update pipeline: passServiceLinks() replaces passHTTPLinks()
  - Update Louvain to include all 9 edge types

Author: Shidfar Hodizoda

internal/linkutil/config.go

@@ -0,0 +1,278 @@
+package linkutil
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+// LinkerConfig holds user-overridable service linker settings.
+// Loaded from .cgrconfig in the project root.
+// This is the unified config for all protocol linkers (HTTP, GraphQL, gRPC, Kafka, SQS, SNS, PubSub).
+type LinkerConfig struct {
+	HTTPLinker    HTTPLinkerConfig    `yaml:"http_linker"`
+	GraphQLLinker GraphQLLinkerConfig `yaml:"graphql_linker"`
+	GRPCLinker    GRPCLinkerConfig    `yaml:"grpc_linker"`
+	KafkaLinker   KafkaLinkerConfig   `yaml:"kafka_linker"`
+	SQSLinker     SQSLinkerConfig     `yaml:"sqs_linker"`
+	SNSLinker     SNSLinkerConfig     `yaml:"sns_linker"`
+	PubSubLinker  PubSubLinkerConfig  `yaml:"pubsub_linker"`
+}
+
+// HTTPLinkerConfig holds HTTP linker-specific settings.
+type HTTPLinkerConfig struct {
+	// ExcludePaths are route paths to exclude from HTTP_CALLS matching.
+	// These are added to (not replacing) the built-in defaultExcludePaths.
+	ExcludePaths []string `yaml:"exclude_paths"`
+
+	// MinConfidence is the minimum confidence score for creating HTTP_CALLS edges.
+	// Default: 0.25 (includes speculative matches).
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy URL matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// KafkaLinkerConfig holds Kafka linker-specific settings.
+type KafkaLinkerConfig struct {
+	// ExcludeTopics are topic names/patterns to exclude from PUBLISHES_TO/SUBSCRIBES_TO matching.
+	ExcludeTopics []string `yaml:"exclude_topics"`
+
+	// MinConfidence is the minimum confidence score for creating Kafka edges.
+	// Default: 0.25.
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy topic matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// SQSLinkerConfig holds SQS linker-specific settings.
+type SQSLinkerConfig struct {
+	// ExcludeQueues are queue names/patterns to exclude from SQS_SENDS_TO/SQS_RECEIVES_FROM matching.
+	ExcludeQueues []string `yaml:"exclude_queues"`
+
+	// MinConfidence is the minimum confidence score for creating SQS edges.
+	// Default: 0.25.
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy queue name matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// SNSLinkerConfig holds SNS linker-specific settings.
+type SNSLinkerConfig struct {
+	// ExcludeTopics are topic ARNs/patterns to exclude from SNS_PUBLISHES_TO/SNS_SUBSCRIBES_TO matching.
+	ExcludeTopics []string `yaml:"exclude_topics"`
+
+	// MinConfidence is the minimum confidence score for creating SNS edges.
+	// Default: 0.25.
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy topic matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// PubSubLinkerConfig holds GCP Pub/Sub linker-specific settings.
+type PubSubLinkerConfig struct {
+	// ExcludeTopics are topic names/patterns to exclude from PUBSUB_CALLS matching.
+	ExcludeTopics []string `yaml:"exclude_topics"`
+
+	// MinConfidence is the minimum confidence score for creating PubSub edges.
+	// Default: 0.25.
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy topic matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// GraphQLLinkerConfig holds GraphQL linker-specific settings.
+type GraphQLLinkerConfig struct {
+	// ExcludeOperations are operation names/patterns to exclude from GRAPHQL_CALLS matching.
+	ExcludeOperations []string `yaml:"exclude_operations"`
+
+	// MinConfidence is the minimum confidence score for creating GraphQL edges.
+	// Default: 0.25.
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy operation matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// GRPCLinkerConfig holds gRPC linker-specific settings.
+type GRPCLinkerConfig struct {
+	// ExcludeServices are service names/patterns to exclude from GRPC_CALLS matching.
+	ExcludeServices []string `yaml:"exclude_services"`
+
+	// MinConfidence is the minimum confidence score for creating gRPC edges.
+	// Default: 0.25.
+	MinConfidence *float64 `yaml:"min_confidence"`
+
+	// FuzzyMatching enables/disables fuzzy service/method matching.
+	// Default: true.
+	FuzzyMatching *bool `yaml:"fuzzy_matching"`
+}
+
+// DefaultConfig returns the default linker configuration.
+func DefaultConfig() *LinkerConfig {
+	return &LinkerConfig{}
+}
+
+// LoadConfig reads .cgrconfig from the given directory.
+// Returns default config if the file doesn't exist.
+func LoadConfig(dir string) *LinkerConfig {
+	cfg := DefaultConfig()
+
+	path := filepath.Join(dir, ".cgrconfig")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return cfg // file not found or unreadable — use defaults
+	}
+
+	if err := yaml.Unmarshal(data, cfg); err != nil {
+		return DefaultConfig() // invalid YAML — use defaults
+	}
+
+	return cfg
+}
+
+// EffectiveMinConfidence returns the configured minimum confidence for HTTP linker,
+// or the default (0.25) if not set.
+func (c *LinkerConfig) EffectiveMinConfidence() float64 {
+	if c.HTTPLinker.MinConfidence != nil {
+		return *c.HTTPLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// EffectiveFuzzyMatching returns the configured fuzzy matching setting for HTTP linker,
+// or the default (true) if not set.
+func (c *LinkerConfig) EffectiveFuzzyMatching() bool {
+	if c.HTTPLinker.FuzzyMatching != nil {
+		return *c.HTTPLinker.FuzzyMatching
+	}
+	return true
+}
+
+// AllExcludePaths returns the combined list of default + user-configured exclude paths for HTTP.
+func (c *LinkerConfig) AllExcludePaths(defaultPaths []string) []string {
+	combined := make([]string, 0, len(defaultPaths)+len(c.HTTPLinker.ExcludePaths))
+	combined = append(combined, defaultPaths...)
+	combined = append(combined, c.HTTPLinker.ExcludePaths...)
+	return combined
+}
+
+// KafkaEffectiveMinConfidence returns the configured minimum confidence for Kafka linker.
+func (c *LinkerConfig) KafkaEffectiveMinConfidence() float64 {
+	if c.KafkaLinker.MinConfidence != nil {
+		return *c.KafkaLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// KafkaEffectiveFuzzyMatching returns the configured fuzzy matching setting for Kafka linker.
+func (c *LinkerConfig) KafkaEffectiveFuzzyMatching() bool {
+	if c.KafkaLinker.FuzzyMatching != nil {
+		return *c.KafkaLinker.FuzzyMatching
+	}
+	return true
+}
+
+// SQSEffectiveMinConfidence returns the configured minimum confidence for SQS linker.
+func (c *LinkerConfig) SQSEffectiveMinConfidence() float64 {
+	if c.SQSLinker.MinConfidence != nil {
+		return *c.SQSLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// SQSEffectiveFuzzyMatching returns the configured fuzzy matching setting for SQS linker.
+func (c *LinkerConfig) SQSEffectiveFuzzyMatching() bool {
+	if c.SQSLinker.FuzzyMatching != nil {
+		return *c.SQSLinker.FuzzyMatching
+	}
+	return true
+}
+
+// SNSEffectiveMinConfidence returns the configured minimum confidence for SNS linker.
+func (c *LinkerConfig) SNSEffectiveMinConfidence() float64 {
+	if c.SNSLinker.MinConfidence != nil {
+		return *c.SNSLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// SNSEffectiveFuzzyMatching returns the configured fuzzy matching setting for SNS linker.
+func (c *LinkerConfig) SNSEffectiveFuzzyMatching() bool {
+	if c.SNSLinker.FuzzyMatching != nil {
+		return *c.SNSLinker.FuzzyMatching
+	}
+	return true
+}
+
+// PubSubEffectiveMinConfidence returns the configured minimum confidence for PubSub linker.
+func (c *LinkerConfig) PubSubEffectiveMinConfidence() float64 {
+	if c.PubSubLinker.MinConfidence != nil {
+		return *c.PubSubLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// PubSubEffectiveFuzzyMatching returns the configured fuzzy matching setting for PubSub linker.
+func (c *LinkerConfig) PubSubEffectiveFuzzyMatching() bool {
+	if c.PubSubLinker.FuzzyMatching != nil {
+		return *c.PubSubLinker.FuzzyMatching
+	}
+	return true
+}
+
+// GraphQLEffectiveMinConfidence returns the configured minimum confidence for GraphQL linker.
+func (c *LinkerConfig) GraphQLEffectiveMinConfidence() float64 {
+	if c.GraphQLLinker.MinConfidence != nil {
+		return *c.GraphQLLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// GraphQLEffectiveFuzzyMatching returns the configured fuzzy matching setting for GraphQL linker.
+func (c *LinkerConfig) GraphQLEffectiveFuzzyMatching() bool {
+	if c.GraphQLLinker.FuzzyMatching != nil {
+		return *c.GraphQLLinker.FuzzyMatching
+	}
+	return true
+}
+
+// GRPCEffectiveMinConfidence returns the configured minimum confidence for gRPC linker.
+func (c *LinkerConfig) GRPCEffectiveMinConfidence() float64 {
+	if c.GRPCLinker.MinConfidence != nil {
+		return *c.GRPCLinker.MinConfidence
+	}
+	return 0.25
+}
+
+// GRPCEffectiveFuzzyMatching returns the configured fuzzy matching setting for gRPC linker.
+func (c *LinkerConfig) GRPCEffectiveFuzzyMatching() bool {
+	if c.GRPCLinker.FuzzyMatching != nil {
+		return *c.GRPCLinker.FuzzyMatching
+	}
+	return true
+}
+
+// IsPathExcluded checks if a route path matches any of the given exclusion paths.
+// This is a generic helper for path/topic/queue exclusion.
+func IsPathExcluded(path string, excludePaths []string) bool {
+	normalized := strings.ToLower(strings.TrimRight(path, "/"))
+	for _, excluded := range excludePaths {
+		if strings.EqualFold(normalized, strings.TrimRight(excluded, "/")) {
+			return true
+		}
+	}
+	return false
+}