feat: add language-frontend extractors for graph parity

crates/no-mistakes/src/codebase/dependencies/args_relationships.rs

@@ -36,6 +36,11 @@ pub enum RelationshipArg {
     Dotnet,
     Swift,
     Terraform,
+    Python,
+    Go,
+    Rust,
+    Ruby,
+    Php,
     Resource,
     All,
 }
@@ -81,6 +86,11 @@ impl RelationshipArg {
             Self::Dotnet => "dotnet",
             Self::Swift => "swift",
             Self::Terraform => "terraform",
+            Self::Python => "python",
+            Self::Go => "go",
+            Self::Rust => "rust",
+            Self::Ruby => "ruby",
+            Self::Php => "php",
             Self::Resource => "resource",
             Self::All => "all",
             Self::Workflow

crates/no-mistakes/src/codebase/dependencies/args_relationships_filter.rs

@@ -77,6 +77,11 @@ fn non_workflow_relationship_edges(relationship: &RelationshipArg) -> &'static [
                 EdgeKind::TerraformModuleRef,
                 EdgeKind::TerraformOutputRef,
             ],
+        RelationshipArg::Python => &[EdgeKind::PythonImport, EdgeKind::PythonReference],
+        RelationshipArg::Go => &[EdgeKind::GoImport, EdgeKind::GoReference],
+        RelationshipArg::Rust => &[EdgeKind::RustUse, EdgeKind::RustMod, EdgeKind::RustPackage],
+        RelationshipArg::Ruby => &[EdgeKind::RubyRequire, EdgeKind::RubyReference],
+        RelationshipArg::Php => &[EdgeKind::PhpUse, EdgeKind::PhpPackage],
         RelationshipArg::Resource => &[EdgeKind::Resource],
         RelationshipArg::Workflow
         | RelationshipArg::WorkflowJob
@@ -136,6 +141,17 @@ fn standard_relationship_edges() -> std::collections::HashSet<EdgeKind> {
         EdgeKind::TerraformReference,
         EdgeKind::TerraformModuleRef,
         EdgeKind::TerraformOutputRef,
+        EdgeKind::PythonImport,
+        EdgeKind::PythonReference,
+        EdgeKind::GoImport,
+        EdgeKind::GoReference,
+        EdgeKind::RustUse,
+        EdgeKind::RustMod,
+        EdgeKind::RustPackage,
+        EdgeKind::RubyRequire,
+        EdgeKind::RubyReference,
+        EdgeKind::PhpUse,
+        EdgeKind::PhpPackage,
         EdgeKind::Resource,
     ]
     .into_iter()

crates/no-mistakes/src/codebase/dependencies/args_test_globs.rs

@@ -46,6 +46,14 @@ pub(crate) fn test_globs(framework: &str) -> Vec<String> {
         "cargo" => globs_to_strings(CARGO),
         "dotnet" => globs_to_strings(DOTNET),
         "swift" => globs_to_strings(SWIFT),
+        "python" => globs_to_strings(&[
+            "**/test_*.py",
+            "**/*_test.py",
+            "**/tests/**/*.py",
+        ]),
+        "go" => globs_to_strings(&["**/*_test.go"]),
+        "rails" => globs_to_strings(&["**/spec/**/*_spec.rb", "**/test/**/*_test.rb"]),
+        "php" => globs_to_strings(&["**/*Test.php", "**/tests/**/*.php"]),
         _ => vec![],
     }
 }

crates/no-mistakes/src/codebase/dependencies/graph/build_plan.rs

@@ -25,6 +25,7 @@ pub struct GraphBuildPlan {
     pub dotnet: bool,
     pub swift: bool,
     pub terraform: bool,
+    pub language_frontends: bool,
 }
 
 impl GraphBuildPlan {
@@ -54,6 +55,7 @@ impl GraphBuildPlan {
             dotnet: true,
             swift: true,
             terraform: true,
+            language_frontends: true,
         }
     }
 
@@ -125,6 +127,17 @@ impl GraphBuildPlan {
             terraform: allowed.contains(&EdgeKind::TerraformReference)
                 || allowed.contains(&EdgeKind::TerraformModuleRef)
                 || allowed.contains(&EdgeKind::TerraformOutputRef),
+            language_frontends: allowed.contains(&EdgeKind::PythonImport)
+                || allowed.contains(&EdgeKind::PythonReference)
+                || allowed.contains(&EdgeKind::GoImport)
+                || allowed.contains(&EdgeKind::GoReference)
+                || allowed.contains(&EdgeKind::RustUse)
+                || allowed.contains(&EdgeKind::RustMod)
+                || allowed.contains(&EdgeKind::RustPackage)
+                || allowed.contains(&EdgeKind::RubyRequire)
+                || allowed.contains(&EdgeKind::RubyReference)
+                || allowed.contains(&EdgeKind::PhpUse)
+                || allowed.contains(&EdgeKind::PhpPackage),
         }
     }
 
@@ -150,6 +163,7 @@ impl GraphBuildPlan {
         self.dotnet |= other.dotnet;
         self.swift |= other.swift;
         self.terraform |= other.terraform;
+        self.language_frontends |= other.language_frontends;
     }
 
     pub fn with_symbols(mut self, symbols: bool) -> Self {
@@ -175,38 +189,3 @@ impl GraphBuildPlan {
         }
     }
 }
-
-fn graph_plan_needs_config(plan: GraphBuildPlan) -> bool {
-    plan.ci
-        || plan.workflow_topology
-        || plan.routes
-        || plan.queues
-        || plan.http
-        || plan.tests
-        || plan.dotnet
-        || plan.swift
-        || plan.terraform
-}
-
-fn effective_ts_fact_plan(
-    plan: GraphBuildPlan,
-    options: Option<&GraphConfigOptions>,
-) -> TsFactPlan {
-    let mut fact_plan = plan.ts_fact_plan();
-    let route_refs_configured = options.is_some_and(route_ref_facts_configured);
-    let route_backend_configured = options.is_some_and(route_backend_facts_configured);
-    let http_configured = options.is_some_and(http_facts_configured);
-    let queue_configured = options.is_some_and(queue_facts_configured);
-
-    fact_plan.route_refs &= route_refs_configured;
-    fact_plan.backend_routes &= route_backend_configured || http_configured;
-    fact_plan.http_calls &= http_configured;
-    fact_plan.symbols = plan.symbols || (fact_plan.symbols && queue_configured);
-    fact_plan.queue_usage &= queue_configured;
-    fact_plan.queue_factory &= queue_configured;
-    fact_plan.queue_project &= queue_configured;
-    fact_plan.server_routes = options.is_some_and(|options| {
-        options.project_route_globset.is_some() && (plan.routes || plan.swift)
-    });
-    fact_plan
-}

crates/no-mistakes/src/codebase/dependencies/graph/build_plan_facts.rs

@@ -0,0 +1,35 @@
+fn graph_plan_needs_config(plan: GraphBuildPlan) -> bool {
+    plan.ci
+        || plan.workflow_topology
+        || plan.routes
+        || plan.queues
+        || plan.http
+        || plan.tests
+        || plan.dotnet
+        || plan.swift
+        || plan.terraform
+        || plan.language_frontends
+}
+
+fn effective_ts_fact_plan(
+    plan: GraphBuildPlan,
+    options: Option<&GraphConfigOptions>,
+) -> TsFactPlan {
+    let mut fact_plan = plan.ts_fact_plan();
+    let route_refs_configured = options.is_some_and(route_ref_facts_configured);
+    let route_backend_configured = options.is_some_and(route_backend_facts_configured);
+    let http_configured = options.is_some_and(http_facts_configured);
+    let queue_configured = options.is_some_and(queue_facts_configured);
+
+    fact_plan.route_refs &= route_refs_configured;
+    fact_plan.backend_routes &= route_backend_configured || http_configured;
+    fact_plan.http_calls &= http_configured;
+    fact_plan.symbols = plan.symbols || (fact_plan.symbols && queue_configured);
+    fact_plan.queue_usage &= queue_configured;
+    fact_plan.queue_factory &= queue_configured;
+    fact_plan.queue_project &= queue_configured;
+    fact_plan.server_routes = options.is_some_and(|options| {
+        options.project_route_globset.is_some() && (plan.routes || plan.swift)
+    });
+    fact_plan
+}

crates/no-mistakes/src/codebase/dependencies/graph/builder_helpers.rs

@@ -115,6 +115,23 @@ fn merge_dotnet_edges(
     merge_edges(forward, reverse, dotnet_edges);
 }
 
+fn merge_language_frontend_edges(
+    inputs: &GraphEdgeBuildInputs<'_>,
+    forward: &mut EdgeMap,
+    reverse: &mut EdgeMap,
+) {
+    let edges = collect_language_frontend_edges(
+        inputs.root,
+        &inputs.graph_files.all,
+        inputs.config_options,
+    );
+    for (from, to, _) in &edges {
+        forward.entry(from.clone()).or_default();
+        forward.entry(to.clone()).or_default();
+    }
+    merge_edges(forward, reverse, edges);
+}
+
 fn merge_terraform_edges(
     inputs: &GraphEdgeBuildInputs<'_>,
     forward: &mut EdgeMap,

crates/no-mistakes/src/codebase/dependencies/graph/builder_remaining_edges.rs

@@ -165,6 +165,14 @@ fn collect_remaining_edges(
     crate::perf_trace::trace("graph.terraform", || {
         merge_terraform_edges(edge_inputs, forward, reverse);
     });
+    crate::perf_trace::trace("graph.language_frontends", || {
+        if edge_inputs.plan.language_frontends
+            || edge_inputs.plan.queues
+            || edge_inputs.plan.routes
+        {
+            merge_language_frontend_edges(edge_inputs, forward, reverse);
+        }
+    });
     crate::invocation::check_timeout()?;
     Ok(())
 }

crates/no-mistakes/src/codebase/dependencies/graph/edge_lang_domains.rs

@@ -0,0 +1,116 @@
+fn emit_route_edges(facts: &LangFactMap, edges: &mut Vec<Edge>) {
+    for file in facts.files.values() {
+        for (_, handler) in &file.route_handlers {
+            for name in route_handler_names(handler) {
+                if let Some(targets) = facts.declarations.get(&name) {
+                    let scoped: std::collections::BTreeSet<_> = targets
+                        .iter()
+                        .filter(|target| {
+                            file.package.is_none()
+                                || facts
+                                    .files
+                                    .get(*target)
+                                    .and_then(|other| other.package.as_ref())
+                                    == file.package.as_ref()
+                        })
+                        .cloned()
+                        .collect();
+                    push_file_edges(edges, &file.path, &scoped, EdgeKind::RouteRef);
+                }
+            }
+        }
+    }
+}
+
+fn route_handler_names(handler: &str) -> Vec<String> {
+    let trimmed = handler.replace(['\'', '"', ' '], "");
+    if let Some((controller, _)) = trimmed.split_once('#') {
+        let mut name = controller.replace('/', "_");
+        if !name.ends_with("Controller") {
+            name.push_str("Controller");
+        }
+        return vec![snake_to_pascal(&name), name];
+    }
+    if let Some((class, _)) = trimmed.split_once("::") {
+        return vec![class.rsplit('\\').next().unwrap_or(class).to_string()];
+    }
+    vec![trimmed.rsplit('.').next().unwrap_or(&trimmed).to_string()]
+}
+
+fn snake_to_pascal(name: &str) -> String {
+    name.split('_')
+        .filter(|part| !part.is_empty())
+        .map(|part| {
+            let mut chars = part.chars();
+            match chars.next() {
+                Some(first) => first.to_ascii_uppercase().to_string() + chars.as_str(),
+                None => String::new(),
+            }
+        })
+        .collect()
+}
+
+fn emit_kafka_edges(
+    root: &Path,
+    all_files: &[PathBuf],
+    options: &GraphConfigOptions,
+    edges: &mut Vec<Edge>,
+) {
+    let cluster = options.queue_cluster.as_deref();
+    let mut produces = Vec::new();
+    let mut consumes = Vec::new();
+    for path in all_files {
+        let Some((prod, cons)) = scan_kafka_file(path) else {
+            continue;
+        };
+        let rel = path.strip_prefix(root).unwrap_or(path);
+        let rel_s = rel.to_string_lossy();
+        if matches_any(&rel_s, &options.queue_enqueues) {
+            produces.push((path.clone(), prod));
+        }
+        if matches_any(&rel_s, &options.queue_workers) {
+            consumes.push((path.clone(), cons));
+        }
+    }
+    let mut workers: std::collections::HashMap<String, std::collections::BTreeSet<PathBuf>> =
+        std::collections::HashMap::new();
+    for (path, topics) in &consumes {
+        for topic in topics {
+            workers
+                .entry(topic_identity(cluster, topic))
+                .or_default()
+                .insert(path.clone());
+        }
+    }
+    for (path, topics) in produces {
+        for topic in topics {
+            let identity = topic_identity(cluster, &topic);
+            let node = NodeId::QueueJob {
+                queue_file: path.clone(),
+                job: identity.clone(),
+            };
+            edges.push((
+                NodeId::File(path.clone()),
+                node.clone(),
+                EdgeKind::QueueEnqueue,
+            ));
+            if let Some(targets) = workers.get(&identity) {
+                for worker in targets {
+                    edges.push((
+                        node.clone(),
+                        NodeId::File(worker.clone()),
+                        EdgeKind::QueueWorker,
+                    ));
+                }
+            }
+        }
+    }
+}
+
+fn matches_any(rel: &str, globs: &[String]) -> bool {
+    globs.iter().any(|glob| {
+        globset::Glob::new(glob)
+            .ok()
+            .is_some_and(|g| g.compile_matcher().is_match(rel))
+    })
+}