[gobby-cli-#768] feat: label graph edge confidence

Author: joshwilhelmi

crates/gcode/src/commands/graph/reads.rs

@@ -117,6 +117,29 @@ where
     lines.join("\n")
 }
 
+pub(super) fn format_caller_result_line(result: &GraphResult, target_name: &str) -> String {
+    format!(
+        "{} [{}] {} -> {}",
+        result.line, result.confidence, result.name, target_name
+    )
+}
+
+pub(super) fn format_usage_result_line(result: &GraphResult, target_name: &str) -> String {
+    let rel = result.relation.as_deref().unwrap_or("unknown");
+    format!(
+        "{} [{}] [{}] {} -> {}",
+        result.line, result.confidence, rel, result.name, target_name
+    )
+}
+
+pub(super) fn format_blast_radius_result_line(result: &GraphResult) -> String {
+    let distance = result.distance.unwrap_or(0);
+    format!(
+        "{} [{}] [distance={}] {}",
+        result.line, result.confidence, distance, result.name
+    )
+}
+
 #[derive(Serialize)]
 struct GraphPathEndpoint {
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -385,7 +408,7 @@ pub fn callers(
                 eprintln!("No callers at offset {offset} (total {total})");
             } else {
                 output::print_text(&format_grouped_graph_results(&results, |r| {
-                    format!("{} {} -> {}", r.line, r.name, symbol.display_name)
+                    format_caller_result_line(r, &symbol.display_name)
                 }))?;
                 if total > offset + results.len() {
                     eprintln!(
@@ -438,8 +461,7 @@ pub fn usages(
                 eprintln!("No usages at offset {offset} (total {total})");
             } else {
                 output::print_text(&format_grouped_graph_results(&results, |r| {
-                    let rel = r.relation.as_deref().unwrap_or("unknown");
-                    format!("{} [{}] {} -> {}", r.line, rel, r.name, symbol.display_name)
+                    format_usage_result_line(r, &symbol.display_name)
                 }))?;
                 if total > offset + results.len() {
                     eprintln!(
@@ -556,8 +578,7 @@ pub fn blast_radius(
                 print_graph_hint_text(ctx, None);
             } else {
                 output::print_text(&format_grouped_graph_results(&results, |r| {
-                    let dist = r.distance.unwrap_or(0);
-                    format!("{} [distance={}] {}", r.line, dist, r.name)
+                    format_blast_radius_result_line(r)
                 }))?;
             }
             Ok(())

crates/gcode/src/commands/graph/tests.rs

@@ -3,7 +3,10 @@ use super::lifecycle::{
     skipped_missing_indexed_file_payload, skipped_no_graph_facts_payload,
 };
 use super::payload::format_report_text;
-use super::reads::{format_grouped_graph_results, format_symbol_path_text};
+use super::reads::{
+    format_blast_radius_result_line, format_caller_result_line, format_grouped_graph_results,
+    format_symbol_path_text, format_usage_result_line,
+};
 use super::{imports, report};
 use crate::config::Context;
 use crate::graph::code_graph::{self, GraphLifecycleAction, GraphLifecycleOutput};
@@ -59,6 +62,7 @@ fn graph_text_groups_by_file_and_sorts_entries() {
             name: "beta".to_string(),
             file_path: "src/b.rs".to_string(),
             line: 9,
+            confidence: ProjectionProvenance::Extracted,
             relation: Some("CALLS".to_string()),
             distance: None,
             metadata: None,
@@ -68,6 +72,7 @@ fn graph_text_groups_by_file_and_sorts_entries() {
             name: "zeta".to_string(),
             file_path: "src/a.rs".to_string(),
             line: 8,
+            confidence: ProjectionProvenance::Extracted,
             relation: Some("CALLS".to_string()),
             distance: None,
             metadata: None,
@@ -77,6 +82,7 @@ fn graph_text_groups_by_file_and_sorts_entries() {
             name: "alpha".to_string(),
             file_path: "src/a.rs".to_string(),
             line: 3,
+            confidence: ProjectionProvenance::Extracted,
             relation: Some("CALLS".to_string()),
             distance: None,
             metadata: None,
@@ -90,6 +96,33 @@ fn graph_text_groups_by_file_and_sorts_entries() {
     assert_eq!(text, "src/a.rs\n3 alpha\n8 zeta\nsrc/b.rs\n9 beta");
 }
 
+#[test]
+fn graph_read_text_lines_surface_confidence_labels() {
+    let result = GraphResult {
+        id: "sym-1".to_string(),
+        name: "run".to_string(),
+        file_path: "src/lib.rs".to_string(),
+        line: 12,
+        confidence: ProjectionProvenance::Inferred,
+        relation: Some("CALLS".to_string()),
+        distance: Some(2),
+        metadata: None,
+    };
+
+    assert_eq!(
+        format_caller_result_line(&result, "main"),
+        "12 [INFERRED] run -> main"
+    );
+    assert_eq!(
+        format_usage_result_line(&result, "main"),
+        "12 [INFERRED] [CALLS] run -> main"
+    );
+    assert_eq!(
+        format_blast_radius_result_line(&result),
+        "12 [INFERRED] [distance=2] run"
+    );
+}
+
 #[test]
 fn graph_path_text_prints_ordered_chain_with_locations() {
     let path = vec![
@@ -394,6 +427,7 @@ fn top_level_read_commands_preserve_json_shape() {
             name: "run".to_string(),
             file_path: "src/lib.rs".to_string(),
             line: 12,
+            confidence: ProjectionProvenance::Extracted,
             relation: Some("CALLS".to_string()),
             distance: Some(1),
             metadata: None,
@@ -411,6 +445,7 @@ fn top_level_read_commands_preserve_json_shape() {
     assert_eq!(value["results"][0]["name"], "run");
     assert_eq!(value["results"][0]["file_path"], "src/lib.rs");
     assert_eq!(value["results"][0]["line"], 12);
+    assert_eq!(value["results"][0]["confidence"], "EXTRACTED");
     assert_eq!(value["results"][0]["relation"], "CALLS");
     assert_eq!(value["results"][0]["distance"], 1);
     assert!(value["hint"].is_null());
@@ -426,6 +461,7 @@ fn top_level_read_commands_preserve_json_shape() {
             name: "run".to_string(),
             file_path: "src/lib.rs".to_string(),
             line: 12,
+            confidence: ProjectionProvenance::Inferred,
             relation: Some("CALLS".to_string()),
             distance: Some(1),
             metadata: Some(
@@ -437,6 +473,7 @@ fn top_level_read_commands_preserve_json_shape() {
     };
     let value = serde_json::to_value(&response).expect("serialize metadata response");
 
+    assert_eq!(value["results"][0]["confidence"], "INFERRED");
     assert_eq!(
         value["results"][0]["metadata"]["source_file_path"],
         "src/lib.rs"

crates/gcode/src/contract.rs

@@ -594,6 +594,7 @@ fn graph_read_keys() -> Vec<&'static str> {
         "name",
         "file_path",
         "line",
+        "confidence",
         "relation",
         "distance",
         "metadata",

crates/gcode/src/graph/code_graph/read/relationship_queries.rs

@@ -2,7 +2,9 @@ use std::collections::HashMap;
 
 use crate::graph::typed_query;
 
-use super::support::{CALL_TARGET_PREDICATE, clamp_limit, clamp_offset};
+use super::support::{
+    CALL_TARGET_PREDICATE, CONFIDENCE_LABEL_CASE, LINK_METADATA_RETURN, clamp_limit, clamp_offset,
+};
 
 pub(crate) fn count_callers_query(
     project_id: &str,
@@ -47,8 +49,11 @@ pub(crate) fn find_callers_query(
         format!(
             "MATCH (caller:CodeSymbol {{project: $project}})-[r:CALLS]->(target {{id: $id, project: $project}}) \
              WHERE {CALL_TARGET_PREDICATE} \
-             RETURN DISTINCT caller.id AS caller_id, caller.name AS caller_name, \
-                    caller.file_path AS file, caller.line_start AS line \
+             WITH caller, collect(coalesce(r.provenance, 'EXTRACTED')) AS provenances \
+             WITH caller, {CONFIDENCE_LABEL_CASE} AS confidence_label \
+             RETURN caller.id AS caller_id, caller.name AS caller_name, \
+                    caller.file_path AS file, caller.line_start AS line, \
+                    confidence_label AS confidence_label \
              ORDER BY caller.id \
              SKIP {offset} LIMIT {limit}"
         ),
@@ -69,7 +74,8 @@ pub(crate) fn find_usages_query(
             "MATCH (source:CodeSymbol {{project: $project}})-[r:CALLS]->(target {{id: $id, project: $project}}) \
              WHERE {CALL_TARGET_PREDICATE} \
              RETURN source.id AS source_id, source.name AS source_name, \
-                    'CALLS' AS rel_type, r.file AS file, r.line AS line \
+                    'CALLS' AS rel_type, r.file AS file, r.line AS line, \
+                    {LINK_METADATA_RETURN} \
              ORDER BY source.id, r.line, r.file \
              SKIP {offset} LIMIT {limit}"
         ),
@@ -124,9 +130,11 @@ pub(crate) fn find_callers_batch_query(
         format!(
             "MATCH (caller:CodeSymbol {{project: $project}})-[r:CALLS]->(target {{project: $project}}) \
 			 WHERE ({CALL_TARGET_PREDICATE}) AND target.id IN [{ids}] \
-			 WITH caller, min(r.file) AS file, min(r.line) AS line \
+			 WITH caller, min(r.file) AS file, min(r.line) AS line, \
+			      collect(coalesce(r.provenance, 'EXTRACTED')) AS provenances \
+			 WITH caller, file, line, {CONFIDENCE_LABEL_CASE} AS confidence_label \
 			 RETURN caller.id AS caller_id, caller.name AS caller_name, \
-			        file AS file, line AS line \
+			        file AS file, line AS line, confidence_label AS confidence_label \
 			 ORDER BY caller.id \
 			 LIMIT {limit}"
         ),
@@ -164,9 +172,11 @@ pub(crate) fn find_callees_batch_query(
         format!(
             "MATCH (src:CodeSymbol {{project: $project}})-[r:CALLS]->(target {{project: $project}}) \
 			 WHERE src.id IN [{ids}] AND ({CALL_TARGET_PREDICATE}) \
-			 WITH target, min(r.file) AS file, min(r.line) AS line \
+			 WITH target, min(r.file) AS file, min(r.line) AS line, \
+			      collect(coalesce(r.provenance, 'EXTRACTED')) AS provenances \
+			 WITH target, file, line, {CONFIDENCE_LABEL_CASE} AS confidence_label \
 			 RETURN target.id AS callee_id, target.name AS callee_name, \
-			        file AS file, line AS line \
+			        file AS file, line AS line, confidence_label AS confidence_label \
 			 ORDER BY target.id \
 			 LIMIT {limit}"
         ),
@@ -285,3 +295,36 @@ pub(crate) fn blast_radius_query(depth: usize, limit: usize) -> String {
          LIMIT {limit}"
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn callers_query_projects_confidence_without_edge_metadata_duplication() {
+        let (query, _) = find_callers_query("project-1", "symbol-1", 0, 10);
+
+        assert!(query.contains("confidence_label AS confidence_label"));
+        assert!(query.contains("WHEN 'AMBIGUOUS' IN provenances THEN 'AMBIGUOUS'"));
+        assert!(!query.contains("r.confidence AS confidence"));
+    }
+
+    #[test]
+    fn usages_query_projects_edge_confidence_and_metadata() {
+        let (query, _) = find_usages_query("project-1", "symbol-1", 0, 10);
+
+        assert!(query.contains("r.provenance AS provenance"));
+        assert!(query.contains("r.confidence AS confidence"));
+    }
+
+    #[test]
+    fn batched_relationship_queries_project_confidence_label() {
+        let ids = vec!["symbol-1".to_string()];
+
+        let (callers_query, _) = find_callers_batch_query("project-1", &ids, 10);
+        let (callees_query, _) = find_callees_batch_query("project-1", &ids, 10);
+
+        assert!(callers_query.contains("confidence_label AS confidence_label"));
+        assert!(callees_query.contains("confidence_label AS confidence_label"));
+    }
+}

crates/gcode/src/graph/code_graph/read/support.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use crate::graph::typed_query;
-use crate::models::GraphResult;
+use crate::models::{GraphResult, ProjectionProvenance};
 use gobby_core::falkor::Row;
 
 use super::super::payload::{row_string_owned, row_to_projection_metadata, row_usize};
@@ -20,6 +20,11 @@ pub(super) const NEIGHBOR_TYPE_CASE: &str = "CASE \
      WHEN neighbor:ExternalSymbol THEN 'external' \
      ELSE 'unresolved' \
      END";
+pub(super) const CONFIDENCE_LABEL_CASE: &str = "CASE \
+     WHEN 'AMBIGUOUS' IN provenances THEN 'AMBIGUOUS' \
+     WHEN 'INFERRED' IN provenances THEN 'INFERRED' \
+     ELSE 'EXTRACTED' \
+     END";
 pub(super) const NODE_TYPE_CASE: &str = "CASE \
      WHEN n:CodeFile THEN 'file' \
      WHEN n:CodeModule THEN 'module' \
@@ -69,6 +74,12 @@ pub(crate) fn row_to_graph_result(row: &Row) -> GraphResult {
             .and_then(|v| v.as_u64())
             .and_then(|value| usize::try_from(value).ok())
             .unwrap_or(0),
+        confidence: row
+            .get("confidence_label")
+            .or_else(|| row.get("provenance"))
+            .and_then(|v| v.as_str())
+            .and_then(ProjectionProvenance::from_wire_value)
+            .unwrap_or_default(),
         relation: row
             .get("relation")
             .or_else(|| row.get("rel_type"))
@@ -129,3 +140,49 @@ pub(super) fn count_from_rows(rows: &[Row]) -> usize {
         .and_then(|value| usize::try_from(value).ok())
         .unwrap_or(0)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn graph_result_confidence_defaults_to_extracted_without_metadata() {
+        let row = Row::from([
+            ("caller_id".to_string(), json!("caller-1")),
+            ("caller_name".to_string(), json!("run")),
+            ("file".to_string(), json!("src/lib.rs")),
+            ("line".to_string(), json!(12)),
+        ]);
+
+        let result = row_to_graph_result(&row);
+
+        assert_eq!(result.confidence, ProjectionProvenance::Extracted);
+        assert!(result.metadata.is_none());
+    }
+
+    #[test]
+    fn graph_result_confidence_uses_provenance_label_with_metadata_score() {
+        let row = Row::from([
+            ("source_id".to_string(), json!("caller-1")),
+            ("source_name".to_string(), json!("run")),
+            ("file".to_string(), json!("src/lib.rs")),
+            ("line".to_string(), json!(12)),
+            ("rel_type".to_string(), json!("CALLS")),
+            ("provenance".to_string(), json!("INFERRED")),
+            ("confidence".to_string(), json!(0.72)),
+            ("source_system".to_string(), json!("semantic")),
+        ]);
+
+        let result = row_to_graph_result(&row);
+
+        assert_eq!(result.confidence, ProjectionProvenance::Inferred);
+        assert_eq!(
+            result
+                .metadata
+                .as_ref()
+                .and_then(|metadata| metadata.confidence),
+            Some(0.72)
+        );
+    }
+}