devlensio 0.6.2 → 1.0.1

package/extractors/rust/src/calls.rs

@@ -0,0 +1,295 @@
+// calls.rs — the CALLS ladder (syntactic — syn does no type resolution).
+//
+// Ladder (each rung documented; later rungs flagged heuristic where fuzzy):
+//   1. Path call `a::b::c()` / `Type::m()`:
+//        a. first segment via the file's use-symbol map (alias → target)
+//        b. module_map.resolve → (file, rest)
+//        c. rest = single name   → FUNCTION in that file (closest_by_path)
+//        d. rest = Type::method  → STRUCT/ENUM/TRAIT in that file, then
+//           methods_by_owner (same file preferred) → METHOD
+//   2. Plain `bar()` → same-file FUNCTION first, then crate-wide name
+//   3. `Type::new()` with the type in scope but NOT imported (same module /
+//      no use statement) → type via closest_by_path, then its methods
+//   4. `self.method()` → methods of the enclosing impl's owner type
+//   5. `x.method()` (other receivers) → no type info → metadata only V1
+//   6. External first segment (a Cargo.toml dep, not std/local) → lazy
+//      [crate]/name::member node (gated)
+//
+// metadata.calls already carries the raw strings (parser); resolved targets
+// are written back as metadata.resolvedCalls.
+
+use crate::contract::{edge, CodeEdge};
+use crate::extractor::{Options, ParsedRepo};
+use crate::fingerprint::ParsedManifest;
+use crate::lookup::LookupMaps;
+use crate::module_map::ModuleMap;
+use crate::parser::ParsedItem;
+use crate::thirdparty::ThirdPartyRegistry;
+
+pub struct CallsOutput {
+    pub edges: Vec<CodeEdge>,
+}
+
+pub fn detect_calls(
+    repo: &ParsedRepo,
+    module_map: &ModuleMap,
+    lookup: &mut LookupMaps,
+    mf: &ParsedManifest,
+    tp: &mut ThirdPartyRegistry,
+    _opts: &Options,
+) -> CallsOutput {
+    let mut edges = vec![];
+
+    for pf in &repo.files {
+        if pf.is_test_file {
+            continue;
+        }
+        for item in &pf.items {
+            if item.is_test || item.calls.is_empty() {
+                continue;
+            }
+            let from = crate::lookup::node_id_for_item(&pf.rel_path, item);
+            if from.is_empty() {
+                continue;
+            }
+            let base_module = crate::walker::module_path_for_file(&pf.rel_path);
+            let mut resolved: Vec<String> = vec![];
+            for call in &item.calls {
+                if let Some(target) = resolve_call(
+                    call,
+                    item,
+                    &pf.rel_path,
+                    &base_module,
+                    module_map,
+                    lookup,
+                    mf,
+                    tp,
+                ) {
+                    edges.push(edge(&from, &target, "CALLS"));
+                    resolved.push(target);
+                }
+            }
+            if !resolved.is_empty() {
+                // write metadata.resolvedCalls back (nodes are owned by the
+                // registry; clone → mutate → reinsert)
+                if let Some(node) = lookup.node_by_id.get(&from).cloned() {
+                    let mut n = node;
+                    let r: Vec<serde_json::Value> = resolved
+                        .iter()
+                        .map(|s| serde_json::Value::from(s.clone()))
+                        .collect();
+                    n.metadata
+                        .insert("resolvedCalls".to_string(), serde_json::Value::Array(r));
+                    lookup.node_by_id.insert(from, n);
+                }
+            }
+        }
+    }
+
+    CallsOutput { edges }
+}
+
+/// Resolve one call string → target node id (or None).
+#[allow(clippy::too_many_arguments)]
+fn resolve_call(
+    call: &str,
+    item: &ParsedItem,
+    rel_path: &str,
+    base_module: &str,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+    mf: &ParsedManifest,
+    tp: &mut ThirdPartyRegistry,
+) -> Option<String> {
+    // `x.method()` — receiver form
+    if let Some((recv, method)) = call.split_once('.') {
+        if recv == "self" {
+            // methods of the enclosing impl's owner type
+            let owner = &item.impl_target;
+            if owner.is_empty() {
+                return None;
+            }
+            return method_of_owner(owner, method, rel_path, lookup);
+        }
+        // other receivers: no type resolution in V1 — metadata only
+        return None;
+    }
+    resolve_path_call(call, rel_path, base_module, module_map, lookup, mf, tp)
+}
+
+/// Resolve a path-form call (`a::b::c`, `Type::m`, plain `bar`) to a node id.
+/// Shared by the CALLS ladder and utoipa-axum route handlers (routes.rs).
+///
+/// Ladder (documented Rust semantics): first segment via the file's use-symbol
+/// map → module map resolve (relative-first for call paths) → glob-import
+/// unroll (`use crate::controllers::*` brings `krate` into scope) → external
+/// crate → lazy [crate]/name::member (gated).
+pub fn resolve_path_call(
+    call: &str,
+    rel_path: &str,
+    base_module: &str,
+    module_map: &ModuleMap,
+    lookup: &LookupMaps,
+    mf: &ParsedManifest,
+    tp: &mut ThirdPartyRegistry,
+) -> Option<String> {
+    let segs: Vec<&str> = call.split("::").collect();
+    if segs.is_empty() {
+        return None;
+    }
+    if segs.len() == 1 {
+        // plain name → same-file FUNCTION, then crate-wide
+        if let Some(id) = lookup.closest_by_path(segs[0], rel_path) {
+            return Some(id);
+        }
+        return None;
+    }
+
+    // multi-segment path — first segment via symbol map, then module resolve
+    let sym_target = lookup
+        .symbol_maps
+        .get(rel_path)
+        .and_then(|syms| syms.get(segs[0]))
+        .cloned();
+    let full_path = match &sym_target {
+        Some(t) => format!("{}::{}", t, segs[1..].join("::")),
+        None => call.to_string(),
+    };
+
+    // Relative-first module resolution (the call-path ladder). NOTE: when
+    // the caller's own file IS a module (e.g. src/router.rs → module
+    // "router"), bare paths like `krate::search::list_crates` resolve
+    // relative-first to `router::krate::...` → matches the file's OWN module
+    // → returns (src/router.rs, "krate::search::list_crates") →
+    // resolve_in_file finds no item_by_module_name["router::krate"] → None.
+    // That None is NOT a hard failure — fall through to glob unroll +
+    // crate-root absolute, where utoipa `routes!(krate::search::list_crates)`
+    // handlers actually live (brought into scope via `use crate::controllers::*;`).
+    if let Some((file, rest)) = module_map.resolve(&full_path, base_module) {
+        if let Some(id) = resolve_in_file(&file, &rest, rel_path, lookup) {
+            return Some(id);
+        }
+        // don't return None — fall through to glob unroll + crate-root
+    }
+
+    // glob unroll: `use crate::controllers::*;` brings `krate` into scope, so
+    // `krate::search::list_crates` resolves as `crate::controllers::krate::
+    // search::list_crates` (documented Rust glob-import semantics)
+    if sym_target.is_none() {
+        if let Some(globs) = lookup.glob_maps.get(rel_path) {
+            for g in globs {
+                let cand = format!("{}::{}", g, full_path);
+                if let Some((file, rest)) = module_map.resolve(&cand, base_module) {
+                    if let Some(id) = resolve_in_file(&file, &rest, rel_path, lookup) {
+                        return Some(id);
+                    }
+                }
+            }
+        }
+    }
+
+    // crate-root absolute fallback. A bare multi-segment path whose first
+    // segment is a local module resolves from the CRATE ROOT in edition 2018
+    // (same semantics as use-paths — `krate::search::list_crates` from
+    // src/router.rs means `crate::krate::search::list_crates`, NOT
+    // `router::krate::...`). resolve_use() is crate-root-absolute and won't
+    // misresolve against the caller's own module.
+    if let Some((file, rest)) = module_map.resolve_use(&full_path, base_module) {
+        if let Some(id) = resolve_in_file(&file, &rest, rel_path, lookup) {
+            return Some(id);
+        }
+    }
+
+    // external crate (a dep, not std, not local) → lazy member node
+    let first = crate::thirdparty::first_segment(&full_path);
+    if crate::thirdparty::is_std(first) {
+        return None;
+    }
+    if crate::thirdparty::is_external_crate(first, mf) {
+        let member = full_path.split("::").skip(1).collect::<Vec<_>>().join("::");
+        return tp.member_node(first, &member).map(|n| n.id.clone());
+    }
+    None
+}
+
+/// Resolve `rest` (item path within `file`) → node id.
+fn resolve_in_file(file: &str, rest: &str, from_rel: &str, lookup: &LookupMaps) -> Option<String> {
+    if rest.is_empty() {
+        return None;
+    }
+    let file_module = crate::walker::module_path_for_file(file);
+    let parts: Vec<&str> = rest.split("::").collect();
+    if parts.len() == 1 {
+        // single name — FUNCTION (or struct constructor call `Type(...)`)
+        let key = if file_module.is_empty() {
+            parts[0].to_string()
+        } else {
+            format!("{}::{}", file_module, parts[0])
+        };
+        if let Some(id) = lookup.item_by_module_name.get(&key) {
+            return Some(id.clone());
+        }
+        return lookup.closest_by_path(parts[0], file);
+    }
+    // Type::method
+    let ty_key = if file_module.is_empty() {
+        parts[0].to_string()
+    } else {
+        format!("{}::{}", file_module, parts[0])
+    };
+    let type_id = lookup.item_by_module_name.get(&ty_key).cloned();
+    let method = parts[1];
+    if let Some(tid) = type_id {
+        if let Some(mid) = method_of_owner_for_type(parts[0], method, file, lookup) {
+            let _ = tid;
+            return Some(mid);
+        }
+        // trait-dispatch call: `Trait::method(&x)` — the trait name resolved;
+        // find the method among `impl Trait for ...` blocks
+        if let Some(mid) = method_of_trait(parts[0], method, lookup) {
+            return Some(mid);
+        }
+        return None;
+    }
+    // type not found as item — maybe a trait in that module
+    let _ = from_rel;
+    lookup
+        .item_by_module_name
+        .get(&format!("{}::{}", file_module, parts[0]))
+        .cloned()
+        .and_then(|_| method_of_owner(parts[0], method, file, lookup))
+}
+
+/// Method of a trait (resolved via `impl Trait for Type` blocks).
+fn method_of_trait(trait_name: &str, method: &str, lookup: &LookupMaps) -> Option<String> {
+    let ids = lookup.methods_by_trait.get(trait_name)?;
+    // id shapes: `rel::Owner.method` (inherent) / `rel::Owner.method::Trait`
+    ids.iter()
+        .find(|id| id.ends_with(&format!(".{}", method)) || id.contains(&format!(".{}::", method)))
+        .cloned()
+}
+
+/// Method of an owner type: same-file preferred, then any file.
+fn method_of_owner(owner: &str, method: &str, file: &str, lookup: &LookupMaps) -> Option<String> {
+    let ids = lookup.methods_by_owner.get(owner)?;
+    // id shapes: `rel::Owner.method` / `rel::Owner.method::Trait`
+    let matches = |id: &String| {
+        id.ends_with(&format!(".{}", method)) || id.contains(&format!(".{}::", method))
+    };
+    let same_file = ids
+        .iter()
+        .find(|id| id.starts_with(&format!("{}::", file)) && matches(id));
+    match same_file {
+        Some(id) => Some(id.clone()),
+        None => ids.iter().find(|id| matches(id)).cloned(),
+    }
+}
+
+fn method_of_owner_for_type(
+    owner: &str,
+    method: &str,
+    file: &str,
+    lookup: &LookupMaps,
+) -> Option<String> {
+    method_of_owner(owner, method, file, lookup)
+}

package/extractors/rust/src/contract.rs

@@ -0,0 +1,236 @@
+// contract.rs — the JSON shape DevLens Engine expects.
+//
+// Every key here is camelCase to match the TypeScript interfaces in the
+// devlens-engine (src/types.ts, src/extractors/types.ts). This file is the
+// single source of truth for the output shape; other modules never spell
+// keys by hand. Mirrors extractors/go/contract.go.
+//
+// serde_json::Map for `metadata` (free-form per-node extras) and strongly
+// typed structs for everything else. rawDependencies is a BTreeMap so keys
+// serialize sorted (deterministic output — contract rule).
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+use sha2::{Digest, Sha256};
+use std::collections::BTreeMap;
+
+// ── Node types (subset of the engine's NodeType union used by Rust) ──
+pub const NODE_FILE: &str = "FILE";
+pub const NODE_TEST: &str = "TEST";
+pub const NODE_ROUTE: &str = "ROUTE";
+pub const NODE_THIRD_PARTY: &str = "THIRD_PARTY";
+
+// ── Edge types (subset of the engine's EdgeType union used by Rust) ──
+pub const EDGE_READS_FROM: &str = "READS_FROM";
+pub const EDGE_WRITES_TO: &str = "WRITES_TO";
+
+// codeHash = sha256(rawCode) hex-encoded, first 16 chars (contract rule).
+pub fn code_hash(raw: &str) -> String {
+    let mut h = Sha256::new();
+    h.update(raw.as_bytes());
+    let sum = h.finalize();
+    hex16(&sum)
+}
+
+fn hex16(bytes: &[u8]) -> String {
+    let mut s = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        s.push_str(&format!("{:02x}", b));
+    }
+    s.chars().take(16).collect()
+}
+
+// ── Fingerprint ──
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Fingerprint {
+    pub language: String,
+    pub project_type: String,
+    pub framework: String,
+    pub router: String,
+    pub state_management: Vec<String>,
+    pub data_fetching: Vec<String>,
+    pub databases: Vec<String>,
+    pub raw_dependencies: BTreeMap<String, String>,
+}
+
+impl Fingerprint {
+    pub fn new() -> Self {
+        Fingerprint {
+            language: "rust".to_string(),
+            project_type: "unknown".to_string(),
+            framework: "unknown".to_string(),
+            router: "none".to_string(),
+            state_management: vec![],
+            data_fetching: vec![],
+            databases: vec![],
+            raw_dependencies: BTreeMap::new(),
+        }
+    }
+}
+
+// ── Stats / Errors / Result ──
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Stats {
+    pub total_files: i64,
+    pub total_nodes: i64,
+    pub skipped_files: i64,
+}
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtractorError {
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub file: String,
+    pub error: String,
+}
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtractorResult {
+    pub fingerprint: Fingerprint,
+    pub nodes: Vec<CodeNode>,
+    pub edges: Vec<CodeEdge>,
+    pub routes: Vec<RouteNode>,
+    pub stats: Stats,
+    pub errors: Vec<ExtractorError>,
+}
+
+// ── Input (stdin) ──
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtractorInput {
+    pub repo_path: String,
+    #[serde(default)]
+    pub options: Value,
+}
+
+// ── Nodes / edges ──
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CodeNode {
+    pub id: String,
+    pub name: String,
+    #[serde(rename = "type")]
+    pub node_type: String,
+    pub file_path: String,
+    pub start_line: i64,
+    pub end_line: i64,
+    pub parent_file: String,
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub code_hash: String,
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub raw_code: String,
+    pub metadata: Map<String, Value>,
+}
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CodeEdge {
+    pub from: String,
+    pub to: String,
+    #[serde(rename = "type")]
+    pub edge_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<Map<String, Value>>,
+}
+
+// ── Routes (the `routes` array — BackendRouteNode shape, mirrors Go) ──
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct RouteNode {
+    #[serde(rename = "type")]
+    pub route_type: String,
+    pub url_path: String,
+    pub file_path: String,
+    pub http_method: String,
+    pub framework: String,
+    pub is_dynamic: bool,
+    pub params: Vec<String>,
+    pub handler_name: String,
+    pub node_id: String,
+}
+
+// ── Builders ──
+
+// Base metadata every code node carries (mirrors the inline JS extractor).
+pub fn base_metadata() -> Map<String, Value> {
+    let mut m = Map::new();
+    m.insert("nodeCount".to_string(), Value::from(0));
+    m.insert("childNodeIds".to_string(), Value::Array(vec![]));
+    m.insert("language".to_string(), Value::from("rust"));
+    m
+}
+
+// fileNode — FILE (or TEST) node. Id format: file::rel/path.rs (matches
+// src/parser/index.ts). File nodes parent themselves.
+pub fn file_node(rel_path: &str, end_line: i64, node_type: &str) -> CodeNode {
+    CodeNode {
+        id: format!("file::{}", rel_path),
+        name: rel_path.rsplit('/').next().unwrap_or(rel_path).to_string(),
+        node_type: node_type.to_string(),
+        file_path: rel_path.to_string(),
+        start_line: 1,
+        end_line,
+        parent_file: format!("file::{}", rel_path),
+        code_hash: String::new(),
+        raw_code: String::new(),
+        metadata: base_metadata(),
+    }
+}
+
+// code_node — FUNCTION/METHOD/STRUCT/ENUM/TRAIT/IMPL_BLOCK/THIRD_PARTY/ROUTE.
+// rawCode on every code node (summarizer input — engine discards after).
+#[allow(clippy::too_many_arguments)]
+pub fn code_node(
+    id: &str,
+    rel_path: &str,
+    name: &str,
+    node_type: &str,
+    start_line: i64,
+    end_line: i64,
+    raw_code: &str,
+    metadata: Map<String, Value>,
+) -> CodeNode {
+    CodeNode {
+        id: id.to_string(),
+        name: name.to_string(),
+        node_type: node_type.to_string(),
+        file_path: rel_path.to_string(),
+        start_line,
+        end_line,
+        parent_file: format!("file::{}", rel_path),
+        code_hash: code_hash(raw_code),
+        raw_code: raw_code.to_string(),
+        metadata,
+    }
+}
+
+pub fn edge(from: &str, to: &str, edge_type: &str) -> CodeEdge {
+    CodeEdge {
+        from: from.to_string(),
+        to: to.to_string(),
+        edge_type: edge_type.to_string(),
+        metadata: None,
+    }
+}
+
+pub fn edge_with_meta(
+    from: &str,
+    to: &str,
+    edge_type: &str,
+    metadata: Map<String, Value>,
+) -> CodeEdge {
+    CodeEdge {
+        from: from.to_string(),
+        to: to.to_string(),
+        edge_type: edge_type.to_string(),
+        metadata: Some(metadata),
+    }
+}

package/extractors/rust/src/enrich.rs

@@ -0,0 +1,107 @@
+// enrich.rs — semantic metadata markers applied as a final pass over the
+// emitted nodes (mirrors go's enrich.go + python's edges/enrich.py).
+//
+// Memo-isolation rule (python incident 10): each marker scan derives from
+// parsed facts independently — no shared memo map that could carry a cached
+// miss between scans.
+//
+// Markers:
+//   isModel / modelType / tableName / tableColumns — Diesel structs
+//   isHandler / handlerKind — targets of HANDLES edges (routes.rs emitted)
+//   isPublic / receiver / isAsync — already set in nodes.rs
+
+use crate::contract::CodeNode;
+use crate::extractor::ParsedRepo;
+
+pub fn enrich_nodes(
+    repo: &ParsedRepo,
+    nodes: &mut [CodeNode],
+    handles_edges: &[crate::contract::CodeEdge],
+) {
+    // ── isHandler: any node that is a HANDLES target ──
+    let mut handler_ids: std::collections::HashSet<String> = std::collections::HashSet::new();
+    for e in handles_edges {
+        if e.edge_type == "HANDLES" {
+            handler_ids.insert(e.to.clone());
+        }
+    }
+    // handlerKind from the HANDLES edge metadata
+    let mut handler_kinds: std::collections::HashMap<String, String> =
+        std::collections::HashMap::new();
+    for e in handles_edges {
+        if e.edge_type == "HANDLES" {
+            if let Some(meta) = &e.metadata {
+                if let Some(k) = meta.get("handlerKind").and_then(|v| v.as_str()) {
+                    handler_kinds.insert(e.to.clone(), k.to_string());
+                }
+            }
+        }
+    }
+
+    // ── Diesel model facts (re-derived from parsed items — orm_edges.rs
+    //    computes the same map for edge targets; single source = facts) ──
+    let table_to_model = crate::orm_edges::table_to_model_map(repo);
+    // table name → columns (for tableColumns metadata)
+    let mut table_columns: std::collections::HashMap<String, Vec<String>> =
+        std::collections::HashMap::new();
+    for pf in &repo.files {
+        for t in &pf.tables {
+            table_columns
+                .entry(t.name.clone())
+                .or_default()
+                .extend(t.columns.iter().map(|(n, _)| n.clone()));
+        }
+    }
+
+    // model id → table name (looked up via the item facts)
+    let mut model_table: std::collections::HashMap<String, String> =
+        std::collections::HashMap::new();
+    for pf in &repo.files {
+        if pf.is_test_file {
+            continue;
+        }
+        for item in &pf.items {
+            if item.kind == crate::parser::KIND_STRUCT && !item.is_test {
+                let id = crate::lookup::struct_node_id(&pf.rel_path, &item.name);
+                if table_to_model.values().any(|v| v == &id) {
+                    let tn = crate::orm_edges::diesel_table_name(item);
+                    if !tn.is_empty() {
+                        model_table.insert(id, tn);
+                    }
+                }
+            }
+        }
+    }
+
+    for n in nodes.iter_mut() {
+        if n.node_type != "FILE" && n.node_type != "TEST" {
+            if handler_ids.contains(&n.id) {
+                n.metadata.insert("isHandler".to_string(), true.into());
+                if let Some(k) = handler_kinds.get(&n.id) {
+                    n.metadata.insert(
+                        "handlerKind".to_string(),
+                        serde_json::Value::from(k.clone()),
+                    );
+                }
+            }
+            if table_to_model.values().any(|v| v == &n.id) {
+                n.metadata.insert("isModel".to_string(), true.into());
+                n.metadata.insert("modelType".to_string(), "diesel".into());
+                if let Some(tn) = model_table.get(&n.id) {
+                    n.metadata
+                        .insert("tableName".to_string(), serde_json::Value::from(tn.clone()));
+                    if let Some(cols) = table_columns.get(tn) {
+                        n.metadata.insert(
+                            "tableColumns".to_string(),
+                            serde_json::Value::Array(
+                                cols.iter()
+                                    .map(|c| serde_json::Value::from(c.clone()))
+                                    .collect(),
+                            ),
+                        );
+                    }
+                }
+            }
+        }
+    }
+}